geneve.c 37.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * GENEVE: Generic Network Virtualization Encapsulation
 *
 * Copyright (c) 2015 Red Hat, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/etherdevice.h>
#include <linux/hash.h>
17
#include <net/dst_metadata.h>
18
#include <net/gro_cells.h>
19 20
#include <net/rtnetlink.h>
#include <net/geneve.h>
21
#include <net/protocol.h>
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

#define GENEVE_NETDEV_VER	"0.6"

#define GENEVE_UDP_PORT		6081

#define GENEVE_N_VID		(1u << 24)
#define GENEVE_VID_MASK		(GENEVE_N_VID - 1)

#define VNI_HASH_BITS		10
#define VNI_HASH_SIZE		(1<<VNI_HASH_BITS)

static bool log_ecn_error = true;
module_param(log_ecn_error, bool, 0644);
MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");

37 38 39
#define GENEVE_VER 0
#define GENEVE_BASE_HLEN (sizeof(struct udphdr) + sizeof(struct genevehdr))

40 41
/* per-network namespace private data for this module */
struct geneve_net {
42 43
	struct list_head	geneve_list;
	struct list_head	sock_list;
44 45
};

46
static unsigned int geneve_net_id;
47

48 49 50 51 52
/* Pseudo network device */
struct geneve_dev {
	struct hlist_node  hlist;	/* vni hash table */
	struct net	   *net;	/* netns for packet i/o */
	struct net_device  *dev;	/* netdev for geneve tunnel */
53
	struct ip_tunnel_info info;
54
	struct geneve_sock __rcu *sock4;	/* IPv4 socket used for geneve tunnel */
55
#if IS_ENABLED(CONFIG_IPV6)
56
	struct geneve_sock __rcu *sock6;	/* IPv6 socket used for geneve tunnel */
57
#endif
58
	struct list_head   next;	/* geneve's per namespace list */
59
	struct gro_cells   gro_cells;
60 61
	bool		   collect_md;
	bool		   use_udp6_rx_checksums;
62 63
};

64 65 66 67 68 69
struct geneve_sock {
	bool			collect_md;
	struct list_head	list;
	struct socket		*sock;
	struct rcu_head		rcu;
	int			refcnt;
70
	struct hlist_head	vni_list[VNI_HASH_SIZE];
71
};
72 73 74 75 76 77 78 79 80

static inline __u32 geneve_net_vni_hash(u8 vni[3])
{
	__u32 vnid;

	vnid = (vni[0] << 16) | (vni[1] << 8) | vni[2];
	return hash_32(vnid, VNI_HASH_BITS);
}

81 82 83 84 85 86 87 88 89 90 91
static __be64 vni_to_tunnel_id(const __u8 *vni)
{
#ifdef __BIG_ENDIAN
	return (vni[0] << 16) | (vni[1] << 8) | vni[2];
#else
	return (__force __be64)(((__force u64)vni[0] << 40) |
				((__force u64)vni[1] << 48) |
				((__force u64)vni[2] << 56));
#endif
}

92 93 94 95 96 97 98 99 100 101 102 103 104 105
/* Convert 64 bit tunnel ID to 24 bit VNI. */
static void tunnel_id_to_vni(__be64 tun_id, __u8 *vni)
{
#ifdef __BIG_ENDIAN
	vni[0] = (__force __u8)(tun_id >> 16);
	vni[1] = (__force __u8)(tun_id >> 8);
	vni[2] = (__force __u8)tun_id;
#else
	vni[0] = (__force __u8)((__force u64)tun_id >> 40);
	vni[1] = (__force __u8)((__force u64)tun_id >> 48);
	vni[2] = (__force __u8)((__force u64)tun_id >> 56);
#endif
}

106 107 108 109 110 111 112 113 114 115 116
static bool eq_tun_id_and_vni(u8 *tun_id, u8 *vni)
{
#ifdef __BIG_ENDIAN
	return (vni[0] == tun_id[2]) &&
	       (vni[1] == tun_id[1]) &&
	       (vni[2] == tun_id[0]);
#else
	return !memcmp(vni, &tun_id[5], 3);
#endif
}

117 118 119 120 121
static sa_family_t geneve_get_sk_family(struct geneve_sock *gs)
{
	return gs->sock->sk->sk_family;
}

122
static struct geneve_dev *geneve_lookup(struct geneve_sock *gs,
123
					__be32 addr, u8 vni[])
124 125
{
	struct hlist_head *vni_list_head;
126
	struct geneve_dev *geneve;
127 128 129
	__u32 hash;

	/* Find the device for this VNI */
130
	hash = geneve_net_vni_hash(vni);
131
	vni_list_head = &gs->vni_list[hash];
132
	hlist_for_each_entry_rcu(geneve, vni_list_head, hlist) {
133
		if (eq_tun_id_and_vni((u8 *)&geneve->info.key.tun_id, vni) &&
134
		    addr == geneve->info.key.u.ipv4.dst)
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
			return geneve;
	}
	return NULL;
}

#if IS_ENABLED(CONFIG_IPV6)
static struct geneve_dev *geneve6_lookup(struct geneve_sock *gs,
					 struct in6_addr addr6, u8 vni[])
{
	struct hlist_head *vni_list_head;
	struct geneve_dev *geneve;
	__u32 hash;

	/* Find the device for this VNI */
	hash = geneve_net_vni_hash(vni);
	vni_list_head = &gs->vni_list[hash];
	hlist_for_each_entry_rcu(geneve, vni_list_head, hlist) {
152
		if (eq_tun_id_and_vni((u8 *)&geneve->info.key.tun_id, vni) &&
153
		    ipv6_addr_equal(&addr6, &geneve->info.key.u.ipv6.dst))
154
			return geneve;
155
	}
156 157
	return NULL;
}
158
#endif
159

160 161 162 163 164
static inline struct genevehdr *geneve_hdr(const struct sk_buff *skb)
{
	return (struct genevehdr *)(udp_hdr(skb) + 1);
}

165 166
static struct geneve_dev *geneve_lookup_skb(struct geneve_sock *gs,
					    struct sk_buff *skb)
167
{
168
	static u8 zero_vni[3];
169
	u8 *vni;
170

171
	if (geneve_get_sk_family(gs) == AF_INET) {
172
		struct iphdr *iph;
173
		__be32 addr;
174

175
		iph = ip_hdr(skb); /* outer IP header... */
176

177 178 179 180
		if (gs->collect_md) {
			vni = zero_vni;
			addr = 0;
		} else {
181
			vni = geneve_hdr(skb)->vni;
182 183 184
			addr = iph->saddr;
		}

185
		return geneve_lookup(gs, addr, vni);
186
#if IS_ENABLED(CONFIG_IPV6)
187
	} else if (geneve_get_sk_family(gs) == AF_INET6) {
188
		static struct in6_addr zero_addr6;
189 190 191
		struct ipv6hdr *ip6h;
		struct in6_addr addr6;

192
		ip6h = ipv6_hdr(skb); /* outer IPv6 header... */
193

194 195 196 197
		if (gs->collect_md) {
			vni = zero_vni;
			addr6 = zero_addr6;
		} else {
198
			vni = geneve_hdr(skb)->vni;
199 200 201
			addr6 = ip6h->saddr;
		}

202
		return geneve6_lookup(gs, addr6, vni);
203 204
#endif
	}
205 206 207 208 209 210 211 212 213 214 215 216
	return NULL;
}

/* geneve receive/decap routine */
static void geneve_rx(struct geneve_dev *geneve, struct geneve_sock *gs,
		      struct sk_buff *skb)
{
	struct genevehdr *gnvh = geneve_hdr(skb);
	struct metadata_dst *tun_dst = NULL;
	struct pcpu_sw_netstats *stats;
	int err = 0;
	void *oiph;
217

218
	if (ip_tunnel_collect_metadata() || gs->collect_md) {
219 220 221 222 223 224
		__be16 flags;

		flags = TUNNEL_KEY | TUNNEL_GENEVE_OPT |
			(gnvh->oam ? TUNNEL_OAM : 0) |
			(gnvh->critical ? TUNNEL_CRIT_OPT : 0);

225
		tun_dst = udp_tun_rx_dst(skb, geneve_get_sk_family(gs), flags,
226 227 228 229 230
					 vni_to_tunnel_id(gnvh->vni),
					 gnvh->opt_len * 4);
		if (!tun_dst)
			goto drop;
		/* Update tunnel dst according to Geneve options. */
231 232
		ip_tunnel_info_opts_set(&tun_dst->u.tun_info,
					gnvh->options, gnvh->opt_len * 4);
233 234 235 236 237 238 239
	} else {
		/* Drop packets w/ critical options,
		 * since we don't support any...
		 */
		if (gnvh->critical)
			goto drop;
	}
240 241 242 243 244

	skb_reset_mac_header(skb);
	skb->protocol = eth_type_trans(skb, geneve->dev);
	skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);

245 246 247
	if (tun_dst)
		skb_dst_set(skb, &tun_dst->dst);

248 249 250 251
	/* Ignore packet loops (and multicast echo) */
	if (ether_addr_equal(eth_hdr(skb)->h_source, geneve->dev->dev_addr))
		goto drop;

252
	oiph = skb_network_header(skb);
253 254
	skb_reset_network_header(skb);

255 256
	if (geneve_get_sk_family(gs) == AF_INET)
		err = IP_ECN_decapsulate(oiph, skb);
257
#if IS_ENABLED(CONFIG_IPV6)
258 259
	else
		err = IP6_ECN_decapsulate(oiph, skb);
260
#endif
261 262

	if (unlikely(err)) {
263
		if (log_ecn_error) {
264
			if (geneve_get_sk_family(gs) == AF_INET)
265 266
				net_info_ratelimited("non-ECT from %pI4 "
						     "with TOS=%#x\n",
267 268
						     &((struct iphdr *)oiph)->saddr,
						     ((struct iphdr *)oiph)->tos);
269
#if IS_ENABLED(CONFIG_IPV6)
270
			else
271
				net_info_ratelimited("non-ECT from %pI6\n",
272
						     &((struct ipv6hdr *)oiph)->saddr);
273 274
#endif
		}
275 276 277 278 279 280 281 282 283 284 285 286 287
		if (err > 1) {
			++geneve->dev->stats.rx_frame_errors;
			++geneve->dev->stats.rx_errors;
			goto drop;
		}
	}

	stats = this_cpu_ptr(geneve->dev->tstats);
	u64_stats_update_begin(&stats->syncp);
	stats->rx_packets++;
	stats->rx_bytes += skb->len;
	u64_stats_update_end(&stats->syncp);

288
	gro_cells_receive(&geneve->gro_cells, skb);
289 290 291 292 293 294 295 296 297
	return;
drop:
	/* Consume bad packet */
	kfree_skb(skb);
}

/* Setup stats when device is created */
static int geneve_init(struct net_device *dev)
{
298 299 300
	struct geneve_dev *geneve = netdev_priv(dev);
	int err;

301 302 303
	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
	if (!dev->tstats)
		return -ENOMEM;
304 305 306 307 308 309 310

	err = gro_cells_init(&geneve->gro_cells, dev);
	if (err) {
		free_percpu(dev->tstats);
		return err;
	}

311
	err = dst_cache_init(&geneve->info.dst_cache, GFP_KERNEL);
P
Paolo Abeni 已提交
312 313 314 315 316
	if (err) {
		free_percpu(dev->tstats);
		gro_cells_destroy(&geneve->gro_cells);
		return err;
	}
317 318 319 320 321
	return 0;
}

static void geneve_uninit(struct net_device *dev)
{
322 323
	struct geneve_dev *geneve = netdev_priv(dev);

324
	dst_cache_destroy(&geneve->info.dst_cache);
325
	gro_cells_destroy(&geneve->gro_cells);
326 327 328
	free_percpu(dev->tstats);
}

329 330 331 332
/* Callback from net/ipv4/udp.c to receive packets */
static int geneve_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
{
	struct genevehdr *geneveh;
333
	struct geneve_dev *geneve;
334 335 336 337 338
	struct geneve_sock *gs;
	int opts_len;

	/* Need Geneve and inner Ethernet header to be present */
	if (unlikely(!pskb_may_pull(skb, GENEVE_BASE_HLEN)))
339
		goto drop;
340 341 342 343

	/* Return packets with reserved bits set */
	geneveh = geneve_hdr(skb);
	if (unlikely(geneveh->ver != GENEVE_VER))
344
		goto drop;
345 346

	if (unlikely(geneveh->proto_type != htons(ETH_P_TEB)))
347
		goto drop;
348

349 350 351 352 353 354 355 356
	gs = rcu_dereference_sk_user_data(sk);
	if (!gs)
		goto drop;

	geneve = geneve_lookup_skb(gs, skb);
	if (!geneve)
		goto drop;

357 358
	opts_len = geneveh->opt_len * 4;
	if (iptunnel_pull_header(skb, GENEVE_BASE_HLEN + opts_len,
359 360
				 htons(ETH_P_TEB),
				 !net_eq(geneve->net, dev_net(geneve->dev))))
361 362
		goto drop;

363
	geneve_rx(geneve, gs, skb);
364 365 366 367 368 369 370 371 372
	return 0;

drop:
	/* Consume bad packet */
	kfree_skb(skb);
	return 0;
}

static struct socket *geneve_create_sock(struct net *net, bool ipv6,
373
					 __be16 port, bool ipv6_rx_csum)
374 375 376 377 378 379 380 381 382
{
	struct socket *sock;
	struct udp_port_cfg udp_conf;
	int err;

	memset(&udp_conf, 0, sizeof(udp_conf));

	if (ipv6) {
		udp_conf.family = AF_INET6;
383
		udp_conf.ipv6_v6only = 1;
384
		udp_conf.use_udp6_rx_checksums = ipv6_rx_csum;
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
	} else {
		udp_conf.family = AF_INET;
		udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
	}

	udp_conf.local_udp_port = port;

	/* Open UDP socket */
	err = udp_sock_create(net, &udp_conf, &sock);
	if (err < 0)
		return ERR_PTR(err);

	return sock;
}

static int geneve_hlen(struct genevehdr *gh)
{
	return sizeof(*gh) + gh->opt_len * 4;
}

405 406 407
static struct sk_buff **geneve_gro_receive(struct sock *sk,
					   struct sk_buff **head,
					   struct sk_buff *skb)
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
{
	struct sk_buff *p, **pp = NULL;
	struct genevehdr *gh, *gh2;
	unsigned int hlen, gh_len, off_gnv;
	const struct packet_offload *ptype;
	__be16 type;
	int flush = 1;

	off_gnv = skb_gro_offset(skb);
	hlen = off_gnv + sizeof(*gh);
	gh = skb_gro_header_fast(skb, off_gnv);
	if (skb_gro_header_hard(skb, hlen)) {
		gh = skb_gro_header_slow(skb, hlen, off_gnv);
		if (unlikely(!gh))
			goto out;
	}

	if (gh->ver != GENEVE_VER || gh->oam)
		goto out;
	gh_len = geneve_hlen(gh);

	hlen = off_gnv + gh_len;
	if (skb_gro_header_hard(skb, hlen)) {
		gh = skb_gro_header_slow(skb, hlen, off_gnv);
		if (unlikely(!gh))
			goto out;
	}

	for (p = *head; p; p = p->next) {
		if (!NAPI_GRO_CB(p)->same_flow)
			continue;

		gh2 = (struct genevehdr *)(p->data + off_gnv);
		if (gh->opt_len != gh2->opt_len ||
		    memcmp(gh, gh2, gh_len)) {
			NAPI_GRO_CB(p)->same_flow = 0;
			continue;
		}
	}

	type = gh->proto_type;

	rcu_read_lock();
	ptype = gro_find_receive_by_type(type);
452
	if (!ptype)
453 454 455 456
		goto out_unlock;

	skb_gro_pull(skb, gh_len);
	skb_gro_postpull_rcsum(skb, gh, gh_len);
S
Sabrina Dubroca 已提交
457
	pp = call_gro_receive(ptype->callbacks.gro_receive, head, skb);
458
	flush = 0;
459 460 461 462 463 464 465 466 467

out_unlock:
	rcu_read_unlock();
out:
	NAPI_GRO_CB(skb)->flush |= flush;

	return pp;
}

468 469
static int geneve_gro_complete(struct sock *sk, struct sk_buff *skb,
			       int nhoff)
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
{
	struct genevehdr *gh;
	struct packet_offload *ptype;
	__be16 type;
	int gh_len;
	int err = -ENOSYS;

	gh = (struct genevehdr *)(skb->data + nhoff);
	gh_len = geneve_hlen(gh);
	type = gh->proto_type;

	rcu_read_lock();
	ptype = gro_find_complete_by_type(type);
	if (ptype)
		err = ptype->callbacks.gro_complete(skb, nhoff + gh_len);

	rcu_read_unlock();
487 488 489

	skb_set_inner_mac_header(skb, nhoff + gh_len);

490 491 492 493 494
	return err;
}

/* Create new listen socket if needed */
static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port,
495
						bool ipv6, bool ipv6_rx_csum)
496 497 498 499 500
{
	struct geneve_net *gn = net_generic(net, geneve_net_id);
	struct geneve_sock *gs;
	struct socket *sock;
	struct udp_tunnel_sock_cfg tunnel_cfg;
501
	int h;
502 503 504 505 506

	gs = kzalloc(sizeof(*gs), GFP_KERNEL);
	if (!gs)
		return ERR_PTR(-ENOMEM);

507
	sock = geneve_create_sock(net, ipv6, port, ipv6_rx_csum);
508 509 510 511 512 513 514
	if (IS_ERR(sock)) {
		kfree(gs);
		return ERR_CAST(sock);
	}

	gs->sock = sock;
	gs->refcnt = 1;
515 516
	for (h = 0; h < VNI_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&gs->vni_list[h]);
517 518

	/* Initialize the geneve udp offloads structure */
519
	udp_tunnel_notify_add_rx_port(gs->sock, UDP_TUNNEL_TYPE_GENEVE);
520 521

	/* Mark socket as an encapsulation socket */
522
	memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
523 524
	tunnel_cfg.sk_user_data = gs;
	tunnel_cfg.encap_type = 1;
525 526
	tunnel_cfg.gro_receive = geneve_gro_receive;
	tunnel_cfg.gro_complete = geneve_gro_complete;
527 528 529 530 531 532 533
	tunnel_cfg.encap_rcv = geneve_udp_encap_recv;
	tunnel_cfg.encap_destroy = NULL;
	setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
	list_add(&gs->list, &gn->sock_list);
	return gs;
}

534
static void __geneve_sock_release(struct geneve_sock *gs)
535
{
536
	if (!gs || --gs->refcnt)
537 538 539
		return;

	list_del(&gs->list);
540
	udp_tunnel_notify_del_rx_port(gs->sock, UDP_TUNNEL_TYPE_GENEVE);
541 542 543 544
	udp_tunnel_sock_release(gs->sock);
	kfree_rcu(gs, rcu);
}

545 546
static void geneve_sock_release(struct geneve_dev *geneve)
{
547
	struct geneve_sock *gs4 = rtnl_dereference(geneve->sock4);
548
#if IS_ENABLED(CONFIG_IPV6)
549 550 551 552 553 554 555 556 557 558 559
	struct geneve_sock *gs6 = rtnl_dereference(geneve->sock6);

	rcu_assign_pointer(geneve->sock6, NULL);
#endif

	rcu_assign_pointer(geneve->sock4, NULL);
	synchronize_net();

	__geneve_sock_release(gs4);
#if IS_ENABLED(CONFIG_IPV6)
	__geneve_sock_release(gs6);
560 561 562
#endif
}

563
static struct geneve_sock *geneve_find_sock(struct geneve_net *gn,
564
					    sa_family_t family,
565 566 567 568 569 570
					    __be16 dst_port)
{
	struct geneve_sock *gs;

	list_for_each_entry(gs, &gn->sock_list, list) {
		if (inet_sk(gs->sock->sk)->inet_sport == dst_port &&
571
		    geneve_get_sk_family(gs) == family) {
572 573 574 575 576 577
			return gs;
		}
	}
	return NULL;
}

578
static int geneve_sock_add(struct geneve_dev *geneve, bool ipv6)
579 580
{
	struct net *net = geneve->net;
581
	struct geneve_net *gn = net_generic(net, geneve_net_id);
582
	struct geneve_sock *gs;
583
	__u8 vni[3];
584
	__u32 hash;
585

586
	gs = geneve_find_sock(gn, ipv6 ? AF_INET6 : AF_INET, geneve->info.key.tp_dst);
587 588 589 590 591
	if (gs) {
		gs->refcnt++;
		goto out;
	}

592 593
	gs = geneve_socket_create(net, geneve->info.key.tp_dst, ipv6,
				  geneve->use_udp6_rx_checksums);
594 595 596
	if (IS_ERR(gs))
		return PTR_ERR(gs);

597 598
out:
	gs->collect_md = geneve->collect_md;
599 600
#if IS_ENABLED(CONFIG_IPV6)
	if (ipv6)
601
		rcu_assign_pointer(geneve->sock6, gs);
602 603
	else
#endif
604
		rcu_assign_pointer(geneve->sock4, gs);
605

606 607
	tunnel_id_to_vni(geneve->info.key.tun_id, vni);
	hash = geneve_net_vni_hash(vni);
608
	hlist_add_head_rcu(&geneve->hlist, &gs->vni_list[hash]);
609 610 611
	return 0;
}

612 613 614
static int geneve_open(struct net_device *dev)
{
	struct geneve_dev *geneve = netdev_priv(dev);
615
	bool ipv6 = !!(geneve->info.mode & IP_TUNNEL_INFO_IPV6);
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
	bool metadata = geneve->collect_md;
	int ret = 0;

#if IS_ENABLED(CONFIG_IPV6)
	if (ipv6 || metadata)
		ret = geneve_sock_add(geneve, true);
#endif
	if (!ret && (!ipv6 || metadata))
		ret = geneve_sock_add(geneve, false);
	if (ret < 0)
		geneve_sock_release(geneve);

	return ret;
}

631 632 633 634
static int geneve_stop(struct net_device *dev)
{
	struct geneve_dev *geneve = netdev_priv(dev);

635 636
	if (!hlist_unhashed(&geneve->hlist))
		hlist_del_rcu(&geneve->hlist);
637
	geneve_sock_release(geneve);
638 639 640
	return 0;
}

641
static void geneve_build_header(struct genevehdr *geneveh,
642
				const struct ip_tunnel_info *info)
643 644
{
	geneveh->ver = GENEVE_VER;
645 646 647
	geneveh->opt_len = info->options_len / 4;
	geneveh->oam = !!(info->key.tun_flags & TUNNEL_OAM);
	geneveh->critical = !!(info->key.tun_flags & TUNNEL_CRIT_OPT);
648
	geneveh->rsvd1 = 0;
649
	tunnel_id_to_vni(info->key.tun_id, geneveh->vni);
650 651 652
	geneveh->proto_type = htons(ETH_P_TEB);
	geneveh->rsvd2 = 0;

653
	ip_tunnel_info_opts_get(geneveh->options, info);
654 655
}

656 657 658
static int geneve_build_skb(struct dst_entry *dst, struct sk_buff *skb,
			    const struct ip_tunnel_info *info,
			    bool xnet, int ip_hdr_len)
659
{
660
	bool udp_sum = !!(info->key.tun_flags & TUNNEL_CSUM);
661 662 663 664
	struct genevehdr *gnvh;
	int min_headroom;
	int err;

665
	skb_reset_mac_header(skb);
666 667
	skb_scrub_packet(skb, xnet);

668 669
	min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len +
		       GENEVE_BASE_HLEN + info->options_len + ip_hdr_len;
670
	err = skb_cow_head(skb, min_headroom);
671
	if (unlikely(err))
672 673
		goto free_dst;

674
	err = udp_tunnel_handle_offloads(skb, udp_sum);
675
	if (err)
676 677
		goto free_dst;

678 679 680
	gnvh = (struct genevehdr *)__skb_push(skb, sizeof(*gnvh) +
						   info->options_len);
	geneve_build_header(gnvh, info);
681 682 683 684 685 686 687 688 689 690 691
	skb_set_inner_protocol(skb, htons(ETH_P_TEB));
	return 0;

free_dst:
	dst_release(dst);
	return err;
}

static struct rtable *geneve_get_v4_rt(struct sk_buff *skb,
				       struct net_device *dev,
				       struct flowi4 *fl4,
692
				       const struct ip_tunnel_info *info)
693
{
694
	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
695
	struct geneve_dev *geneve = netdev_priv(dev);
P
Paolo Abeni 已提交
696
	struct dst_cache *dst_cache;
697 698 699
	struct rtable *rt = NULL;
	__u8 tos;

700 701 702
	if (!rcu_dereference(geneve->sock4))
		return ERR_PTR(-EIO);

703 704 705
	memset(fl4, 0, sizeof(*fl4));
	fl4->flowi4_mark = skb->mark;
	fl4->flowi4_proto = IPPROTO_UDP;
706 707
	fl4->daddr = info->key.u.ipv4.dst;
	fl4->saddr = info->key.u.ipv4.src;
708

709 710 711 712
	tos = info->key.tos;
	if ((tos == 1) && !geneve->collect_md) {
		tos = ip_tunnel_get_dsfield(ip_hdr(skb), skb);
		use_cache = false;
P
Paolo Abeni 已提交
713
	}
714
	fl4->flowi4_tos = RT_TOS(tos);
P
Paolo Abeni 已提交
715

716
	dst_cache = (struct dst_cache *)&info->dst_cache;
P
Paolo Abeni 已提交
717 718 719 720
	if (use_cache) {
		rt = dst_cache_get_ip4(dst_cache, &fl4->saddr);
		if (rt)
			return rt;
721 722 723 724
	}
	rt = ip_route_output_key(geneve->net, fl4);
	if (IS_ERR(rt)) {
		netdev_dbg(dev, "no route to %pI4\n", &fl4->daddr);
725
		return ERR_PTR(-ENETUNREACH);
726 727 728 729
	}
	if (rt->dst.dev == dev) { /* is this necessary? */
		netdev_dbg(dev, "circular route to %pI4\n", &fl4->daddr);
		ip_rt_put(rt);
730
		return ERR_PTR(-ELOOP);
731
	}
P
Paolo Abeni 已提交
732 733
	if (use_cache)
		dst_cache_set_ip4(dst_cache, &rt->dst, fl4->saddr);
734 735 736
	return rt;
}

737 738 739 740
#if IS_ENABLED(CONFIG_IPV6)
static struct dst_entry *geneve_get_v6_dst(struct sk_buff *skb,
					   struct net_device *dev,
					   struct flowi6 *fl6,
741
					   const struct ip_tunnel_info *info)
742
{
743
	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
744 745
	struct geneve_dev *geneve = netdev_priv(dev);
	struct dst_entry *dst = NULL;
P
Paolo Abeni 已提交
746
	struct dst_cache *dst_cache;
747
	struct geneve_sock *gs6;
748
	__u8 prio;
749

750 751 752 753
	gs6 = rcu_dereference(geneve->sock6);
	if (!gs6)
		return ERR_PTR(-EIO);

754 755 756
	memset(fl6, 0, sizeof(*fl6));
	fl6->flowi6_mark = skb->mark;
	fl6->flowi6_proto = IPPROTO_UDP;
757 758 759 760 761 762
	fl6->daddr = info->key.u.ipv6.dst;
	fl6->saddr = info->key.u.ipv6.src;
	prio = info->key.tos;
	if ((prio == 1) && !geneve->collect_md) {
		prio = ip_tunnel_get_dsfield(ip_hdr(skb), skb);
		use_cache = false;
P
Paolo Abeni 已提交
763 764
	}

765 766
	fl6->flowlabel = ip6_make_flowinfo(RT_TOS(prio),
					   info->key.label);
767
	dst_cache = (struct dst_cache *)&info->dst_cache;
P
Paolo Abeni 已提交
768 769 770 771
	if (use_cache) {
		dst = dst_cache_get_ip6(dst_cache, &fl6->saddr);
		if (dst)
			return dst;
772 773 774 775 776 777 778 779 780 781 782
	}
	if (ipv6_stub->ipv6_dst_lookup(geneve->net, gs6->sock->sk, &dst, fl6)) {
		netdev_dbg(dev, "no route to %pI6\n", &fl6->daddr);
		return ERR_PTR(-ENETUNREACH);
	}
	if (dst->dev == dev) { /* is this necessary? */
		netdev_dbg(dev, "circular route to %pI6\n", &fl6->daddr);
		dst_release(dst);
		return ERR_PTR(-ELOOP);
	}

P
Paolo Abeni 已提交
783 784
	if (use_cache)
		dst_cache_set_ip6(dst_cache, dst, &fl6->saddr);
785 786 787 788
	return dst;
}
#endif

789
static int geneve_xmit_skb(struct sk_buff *skb, struct net_device *dev,
790 791
			   struct geneve_dev *geneve,
			   const struct ip_tunnel_info *info)
792
{
793 794 795 796
	bool xnet = !net_eq(geneve->net, dev_net(geneve->dev));
	struct geneve_sock *gs4 = rcu_dereference(geneve->sock4);
	const struct ip_tunnel_key *key = &info->key;
	struct rtable *rt;
797
	struct flowi4 fl4;
798
	__u8 tos, ttl;
799
	__be16 sport;
800
	__be16 df;
801
	int err;
802

803
	rt = geneve_get_v4_rt(skb, dev, &fl4, info);
804 805
	if (IS_ERR(rt))
		return PTR_ERR(rt);
806 807

	sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
808 809
	if (geneve->collect_md) {
		tos = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
810
		ttl = key->ttl;
811
	} else {
812 813
		tos = ip_tunnel_ecn_encap(fl4.flowi4_tos, ip_hdr(skb), skb);
		ttl = key->ttl ? : ip4_dst_hoplimit(&rt->dst);
814
	}
815
	df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
816

817
	err = geneve_build_skb(&rt->dst, skb, info, xnet, sizeof(struct iphdr));
818 819
	if (unlikely(err))
		return err;
H
Haishuang Yan 已提交
820

821 822 823 824 825
	udp_tunnel_xmit_skb(rt, gs4->sock->sk, skb, fl4.saddr, fl4.daddr,
			    tos, ttl, df, sport, geneve->info.key.tp_dst,
			    !net_eq(geneve->net, dev_net(geneve->dev)),
			    !(info->key.tun_flags & TUNNEL_CSUM));
	return 0;
826 827
}

828
#if IS_ENABLED(CONFIG_IPV6)
829
static int geneve6_xmit_skb(struct sk_buff *skb, struct net_device *dev,
830 831
			    struct geneve_dev *geneve,
			    const struct ip_tunnel_info *info)
832
{
833 834 835
	bool xnet = !net_eq(geneve->net, dev_net(geneve->dev));
	struct geneve_sock *gs6 = rcu_dereference(geneve->sock6);
	const struct ip_tunnel_key *key = &info->key;
836 837
	struct dst_entry *dst = NULL;
	struct flowi6 fl6;
838
	__u8 prio, ttl;
839
	__be16 sport;
840
	int err;
841 842

	dst = geneve_get_v6_dst(skb, dev, &fl6, info);
843 844
	if (IS_ERR(dst))
		return PTR_ERR(dst);
845 846

	sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true);
847 848 849 850 851 852 853 854
	if (geneve->collect_md) {
		prio = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
		ttl = key->ttl;
	} else {
		prio = ip_tunnel_ecn_encap(ip6_tclass(fl6.flowlabel),
					   ip_hdr(skb), skb);
		ttl = key->ttl ? : ip6_dst_hoplimit(dst);
	}
855
	err = geneve_build_skb(dst, skb, info, xnet, sizeof(struct ipv6hdr));
856 857
	if (unlikely(err))
		return err;
858

859 860 861 862 863 864 865
	udp_tunnel6_xmit_skb(dst, gs6->sock->sk, skb, dev,
			     &fl6.saddr, &fl6.daddr, prio, ttl,
			     info->key.label, sport, geneve->info.key.tp_dst,
			     !(info->key.tun_flags & TUNNEL_CSUM));
	return 0;
}
#endif
866

867 868 869 870 871
static netdev_tx_t geneve_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct geneve_dev *geneve = netdev_priv(dev);
	struct ip_tunnel_info *info = NULL;
	int err;
872

873 874 875 876 877
	if (geneve->collect_md) {
		info = skb_tunnel_info(skb);
		if (unlikely(!info || !(info->mode & IP_TUNNEL_INFO_TX))) {
			err = -EINVAL;
			netdev_dbg(dev, "no tunnel metadata\n");
878
			goto tx_error;
879
		}
880
	} else {
881
		info = &geneve->info;
882
	}
883

J
Jakub Kicinski 已提交
884
	rcu_read_lock();
885 886 887 888 889 890
#if IS_ENABLED(CONFIG_IPV6)
	if (info->mode & IP_TUNNEL_INFO_IPV6)
		err = geneve6_xmit_skb(skb, dev, geneve, info);
	else
#endif
		err = geneve_xmit_skb(skb, dev, geneve, info);
J
Jakub Kicinski 已提交
891
	rcu_read_unlock();
892

893 894
	if (likely(!err))
		return NETDEV_TX_OK;
895 896
tx_error:
	dev_kfree_skb(skb);
897

898 899 900 901
	if (err == -ELOOP)
		dev->stats.collisions++;
	else if (err == -ENETUNREACH)
		dev->stats.tx_carrier_errors++;
H
Haishuang Yan 已提交
902 903

	dev->stats.tx_errors++;
904 905 906
	return NETDEV_TX_OK;
}

907
static int geneve_change_mtu(struct net_device *dev, int new_mtu)
D
David Wragg 已提交
908
{
909 910
	/* Only possible if called internally, ndo_change_mtu path's new_mtu
	 * is guaranteed to be between dev->min_mtu and dev->max_mtu.
D
David Wragg 已提交
911
	 */
912 913
	if (new_mtu > dev->max_mtu)
		new_mtu = dev->max_mtu;
D
David Wragg 已提交
914

D
David Wragg 已提交
915 916 917 918
	dev->mtu = new_mtu;
	return 0;
}

919 920 921 922 923
static int geneve_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
{
	struct ip_tunnel_info *info = skb_tunnel_info(skb);
	struct geneve_dev *geneve = netdev_priv(dev);

924
	if (ip_tunnel_info_af(info) == AF_INET) {
925 926 927
		struct rtable *rt;
		struct flowi4 fl4;

928 929 930
		rt = geneve_get_v4_rt(skb, dev, &fl4, info);
		if (IS_ERR(rt))
			return PTR_ERR(rt);
931

932 933 934 935
		ip_rt_put(rt);
		info->key.u.ipv4.src = fl4.saddr;
#if IS_ENABLED(CONFIG_IPV6)
	} else if (ip_tunnel_info_af(info) == AF_INET6) {
936 937 938
		struct dst_entry *dst;
		struct flowi6 fl6;

939 940 941 942 943 944 945 946 947 948
		dst = geneve_get_v6_dst(skb, dev, &fl6, info);
		if (IS_ERR(dst))
			return PTR_ERR(dst);

		dst_release(dst);
		info->key.u.ipv6.src = fl6.saddr;
#endif
	} else {
		return -EINVAL;
	}
949 950 951

	info->key.tp_src = udp_flow_src_port(geneve->net, skb,
					     1, USHRT_MAX, true);
952
	info->key.tp_dst = geneve->info.key.tp_dst;
953 954 955
	return 0;
}

956 957 958 959 960 961 962
static const struct net_device_ops geneve_netdev_ops = {
	.ndo_init		= geneve_init,
	.ndo_uninit		= geneve_uninit,
	.ndo_open		= geneve_open,
	.ndo_stop		= geneve_stop,
	.ndo_start_xmit		= geneve_xmit,
	.ndo_get_stats64	= ip_tunnel_get_stats64,
D
David Wragg 已提交
963
	.ndo_change_mtu		= geneve_change_mtu,
964 965
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_set_mac_address	= eth_mac_addr,
966
	.ndo_fill_metadata_dst	= geneve_fill_metadata_dst,
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
};

static void geneve_get_drvinfo(struct net_device *dev,
			       struct ethtool_drvinfo *drvinfo)
{
	strlcpy(drvinfo->version, GENEVE_NETDEV_VER, sizeof(drvinfo->version));
	strlcpy(drvinfo->driver, "geneve", sizeof(drvinfo->driver));
}

static const struct ethtool_ops geneve_ethtool_ops = {
	.get_drvinfo	= geneve_get_drvinfo,
	.get_link	= ethtool_op_get_link,
};

/* Info for udev, that this is a virtual tunnel endpoint */
static struct device_type geneve_type = {
	.name = "geneve",
};

986
/* Calls the ndo_udp_tunnel_add of the caller in order to
987
 * supply the listening GENEVE udp ports. Callers are expected
988
 * to implement the ndo_udp_tunnel_add.
989
 */
990
static void geneve_push_rx_ports(struct net_device *dev)
991 992 993 994
{
	struct net *net = dev_net(dev);
	struct geneve_net *gn = net_generic(net, geneve_net_id);
	struct geneve_sock *gs;
995

996
	rcu_read_lock();
997 998 999
	list_for_each_entry_rcu(gs, &gn->sock_list, list)
		udp_tunnel_push_rx_port(dev, gs->sock,
					UDP_TUNNEL_TYPE_GENEVE);
1000 1001 1002
	rcu_read_unlock();
}

1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
/* Initialize the device structure. */
static void geneve_setup(struct net_device *dev)
{
	ether_setup(dev);

	dev->netdev_ops = &geneve_netdev_ops;
	dev->ethtool_ops = &geneve_ethtool_ops;
	dev->destructor = free_netdev;

	SET_NETDEV_DEVTYPE(dev, &geneve_type);

	dev->features    |= NETIF_F_LLTX;
	dev->features    |= NETIF_F_SG | NETIF_F_HW_CSUM;
	dev->features    |= NETIF_F_RXCSUM;
	dev->features    |= NETIF_F_GSO_SOFTWARE;

	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
	dev->hw_features |= NETIF_F_GSO_SOFTWARE;

1022 1023 1024 1025 1026 1027 1028 1029
	/* MTU range: 68 - (something less than 65535) */
	dev->min_mtu = ETH_MIN_MTU;
	/* The max_mtu calculation does not take account of GENEVE
	 * options, to avoid excluding potentially valid
	 * configurations. This will be further reduced by IPvX hdr size.
	 */
	dev->max_mtu = IP_MAX_MTU - GENEVE_BASE_HLEN - dev->hard_header_len;

1030
	netif_keep_dst(dev);
J
Jiri Benc 已提交
1031
	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1032
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
1033
	eth_hw_addr_random(dev);
1034 1035 1036 1037 1038
}

static const struct nla_policy geneve_policy[IFLA_GENEVE_MAX + 1] = {
	[IFLA_GENEVE_ID]		= { .type = NLA_U32 },
	[IFLA_GENEVE_REMOTE]		= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
1039
	[IFLA_GENEVE_REMOTE6]		= { .len = sizeof(struct in6_addr) },
1040
	[IFLA_GENEVE_TTL]		= { .type = NLA_U8 },
1041
	[IFLA_GENEVE_TOS]		= { .type = NLA_U8 },
1042
	[IFLA_GENEVE_LABEL]		= { .type = NLA_U32 },
1043
	[IFLA_GENEVE_PORT]		= { .type = NLA_U16 },
1044
	[IFLA_GENEVE_COLLECT_METADATA]	= { .type = NLA_FLAG },
1045 1046 1047
	[IFLA_GENEVE_UDP_CSUM]		= { .type = NLA_U8 },
	[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]	= { .type = NLA_U8 },
	[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]	= { .type = NLA_U8 },
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
};

static int geneve_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;

		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}

	if (!data)
		return -EINVAL;

	if (data[IFLA_GENEVE_ID]) {
		__u32 vni =  nla_get_u32(data[IFLA_GENEVE_ID]);

		if (vni >= GENEVE_VID_MASK)
			return -ERANGE;
	}

	return 0;
}

1073
static struct geneve_dev *geneve_find_dev(struct geneve_net *gn,
1074
					  const struct ip_tunnel_info *info,
1075 1076 1077
					  bool *tun_on_same_port,
					  bool *tun_collect_md)
{
1078
	struct geneve_dev *geneve, *t = NULL;
1079 1080 1081 1082

	*tun_on_same_port = false;
	*tun_collect_md = false;
	list_for_each_entry(geneve, &gn->geneve_list, next) {
1083
		if (info->key.tp_dst == geneve->info.key.tp_dst) {
1084 1085 1086
			*tun_collect_md = geneve->collect_md;
			*tun_on_same_port = true;
		}
1087 1088 1089
		if (info->key.tun_id == geneve->info.key.tun_id &&
		    info->key.tp_dst == geneve->info.key.tp_dst &&
		    !memcmp(&info->key.u, &geneve->info.key.u, sizeof(info->key.u)))
1090 1091 1092 1093 1094
			t = geneve;
	}
	return t;
}

1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
static bool is_all_zero(const u8 *fp, size_t size)
{
	int i;

	for (i = 0; i < size; i++)
		if (fp[i])
			return false;
	return true;
}

static bool is_tnl_info_zero(const struct ip_tunnel_info *info)
{
	if (info->key.tun_id || info->key.tun_flags || info->key.tos ||
	    info->key.ttl || info->key.label || info->key.tp_src ||
	    !is_all_zero((const u8 *)&info->key.u, sizeof(info->key.u)))
		return false;
	else
		return true;
}

1115
static int geneve_configure(struct net *net, struct net_device *dev,
1116 1117
			    const struct ip_tunnel_info *info,
			    bool metadata, bool ipv6_rx_csum)
1118 1119
{
	struct geneve_net *gn = net_generic(net, geneve_net_id);
1120 1121
	struct geneve_dev *t, *geneve = netdev_priv(dev);
	bool tun_collect_md, tun_on_same_port;
P
Paolo Abeni 已提交
1122
	int err, encap_len;
1123

1124
	if (metadata && !is_tnl_info_zero(info))
1125
		return -EINVAL;
1126 1127 1128 1129

	geneve->net = net;
	geneve->dev = dev;

1130
	t = geneve_find_dev(gn, info, &tun_on_same_port, &tun_collect_md);
1131 1132 1133
	if (t)
		return -EBUSY;

P
Paolo Abeni 已提交
1134 1135
	/* make enough headroom for basic scenario */
	encap_len = GENEVE_BASE_HLEN + ETH_HLEN;
1136
	if (ip_tunnel_info_af(info) == AF_INET) {
P
Paolo Abeni 已提交
1137
		encap_len += sizeof(struct iphdr);
1138 1139
		dev->max_mtu -= sizeof(struct iphdr);
	} else {
P
Paolo Abeni 已提交
1140
		encap_len += sizeof(struct ipv6hdr);
1141 1142
		dev->max_mtu -= sizeof(struct ipv6hdr);
	}
P
Paolo Abeni 已提交
1143 1144
	dev->needed_headroom = encap_len + ETH_HLEN;

1145 1146 1147 1148 1149 1150 1151 1152
	if (metadata) {
		if (tun_on_same_port)
			return -EPERM;
	} else {
		if (tun_collect_md)
			return -EPERM;
	}

1153 1154 1155 1156
	dst_cache_reset(&geneve->info.dst_cache);
	geneve->info = *info;
	geneve->collect_md = metadata;
	geneve->use_udp6_rx_checksums = ipv6_rx_csum;
P
Paolo Abeni 已提交
1157

1158 1159 1160 1161
	err = register_netdevice(dev);
	if (err)
		return err;

1162 1163 1164 1165
	list_add(&geneve->next, &gn->geneve_list);
	return 0;
}

1166 1167 1168 1169 1170 1171
static void init_tnl_info(struct ip_tunnel_info *info, __u16 dst_port)
{
	memset(info, 0, sizeof(*info));
	info->key.tp_dst = htons(dst_port);
}

1172 1173 1174
static int geneve_newlink(struct net *net, struct net_device *dev,
			  struct nlattr *tb[], struct nlattr *data[])
{
1175 1176
	bool use_udp6_rx_checksums = false;
	struct ip_tunnel_info info;
1177
	bool metadata = false;
1178 1179

	init_tnl_info(&info, GENEVE_UDP_PORT);
1180

1181 1182 1183 1184
	if (data[IFLA_GENEVE_REMOTE] && data[IFLA_GENEVE_REMOTE6])
		return -EINVAL;

	if (data[IFLA_GENEVE_REMOTE]) {
1185
		info.key.u.ipv4.dst =
1186
			nla_get_in_addr(data[IFLA_GENEVE_REMOTE]);
1187 1188 1189 1190 1191

		if (IN_MULTICAST(ntohl(info.key.u.ipv4.dst))) {
			netdev_dbg(dev, "multicast remote is unsupported\n");
			return -EINVAL;
		}
1192 1193 1194
	}

	if (data[IFLA_GENEVE_REMOTE6]) {
1195 1196 1197
 #if IS_ENABLED(CONFIG_IPV6)
		info.mode = IP_TUNNEL_INFO_IPV6;
		info.key.u.ipv6.dst =
1198 1199
			nla_get_in6_addr(data[IFLA_GENEVE_REMOTE6]);

1200
		if (ipv6_addr_type(&info.key.u.ipv6.dst) &
1201 1202 1203 1204
		    IPV6_ADDR_LINKLOCAL) {
			netdev_dbg(dev, "link-local remote is unsupported\n");
			return -EINVAL;
		}
1205 1206 1207 1208 1209 1210 1211 1212 1213
		if (ipv6_addr_is_multicast(&info.key.u.ipv6.dst)) {
			netdev_dbg(dev, "multicast remote is unsupported\n");
			return -EINVAL;
		}
		info.key.tun_flags |= TUNNEL_CSUM;
		use_udp6_rx_checksums = true;
#else
		return -EPFNOSUPPORT;
#endif
1214 1215
	}

1216 1217 1218 1219
	if (data[IFLA_GENEVE_ID]) {
		__u32 vni;
		__u8 tvni[3];

1220
		vni = nla_get_u32(data[IFLA_GENEVE_ID]);
1221 1222 1223
		tvni[0] = (vni & 0x00ff0000) >> 16;
		tvni[1] = (vni & 0x0000ff00) >> 8;
		tvni[2] =  vni & 0x000000ff;
1224

1225 1226
		info.key.tun_id = vni_to_tunnel_id(tvni);
	}
1227
	if (data[IFLA_GENEVE_TTL])
1228
		info.key.ttl = nla_get_u8(data[IFLA_GENEVE_TTL]);
1229

1230
	if (data[IFLA_GENEVE_TOS])
1231
		info.key.tos = nla_get_u8(data[IFLA_GENEVE_TOS]);
1232

1233 1234 1235 1236 1237 1238
	if (data[IFLA_GENEVE_LABEL]) {
		info.key.label = nla_get_be32(data[IFLA_GENEVE_LABEL]) &
				  IPV6_FLOWLABEL_MASK;
		if (info.key.label && (!(info.mode & IP_TUNNEL_INFO_IPV6)))
			return -EINVAL;
	}
1239

1240
	if (data[IFLA_GENEVE_PORT])
1241
		info.key.tp_dst = nla_get_be16(data[IFLA_GENEVE_PORT]);
1242

1243 1244
	if (data[IFLA_GENEVE_COLLECT_METADATA])
		metadata = true;
1245

1246
	if (data[IFLA_GENEVE_UDP_CSUM] &&
1247
	    nla_get_u8(data[IFLA_GENEVE_UDP_CSUM]))
1248
		info.key.tun_flags |= TUNNEL_CSUM;
1249 1250 1251

	if (data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX] &&
	    nla_get_u8(data[IFLA_GENEVE_UDP_ZERO_CSUM6_TX]))
1252
		info.key.tun_flags &= ~TUNNEL_CSUM;
1253 1254 1255

	if (data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX] &&
	    nla_get_u8(data[IFLA_GENEVE_UDP_ZERO_CSUM6_RX]))
1256
		use_udp6_rx_checksums = false;
1257

1258
	return geneve_configure(net, dev, &info, metadata, use_udp6_rx_checksums);
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
}

static void geneve_dellink(struct net_device *dev, struct list_head *head)
{
	struct geneve_dev *geneve = netdev_priv(dev);

	list_del(&geneve->next);
	unregister_netdevice_queue(dev, head);
}

static size_t geneve_get_size(const struct net_device *dev)
{
	return nla_total_size(sizeof(__u32)) +	/* IFLA_GENEVE_ID */
1272
		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_GENEVE_REMOTE{6} */
1273
		nla_total_size(sizeof(__u8)) +  /* IFLA_GENEVE_TTL */
1274
		nla_total_size(sizeof(__u8)) +  /* IFLA_GENEVE_TOS */
1275
		nla_total_size(sizeof(__be32)) +  /* IFLA_GENEVE_LABEL */
1276
		nla_total_size(sizeof(__be16)) +  /* IFLA_GENEVE_PORT */
1277
		nla_total_size(0) +	 /* IFLA_GENEVE_COLLECT_METADATA */
1278 1279 1280
		nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_CSUM */
		nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_TX */
		nla_total_size(sizeof(__u8)) + /* IFLA_GENEVE_UDP_ZERO_CSUM6_RX */
1281 1282 1283 1284 1285 1286
		0;
}

static int geneve_fill_info(struct sk_buff *skb, const struct net_device *dev)
{
	struct geneve_dev *geneve = netdev_priv(dev);
1287 1288
	struct ip_tunnel_info *info = &geneve->info;
	__u8 tmp_vni[3];
1289 1290
	__u32 vni;

1291 1292
	tunnel_id_to_vni(info->key.tun_id, tmp_vni);
	vni = (tmp_vni[0] << 16) | (tmp_vni[1] << 8) | tmp_vni[2];
1293 1294 1295
	if (nla_put_u32(skb, IFLA_GENEVE_ID, vni))
		goto nla_put_failure;

1296
	if (ip_tunnel_info_af(info) == AF_INET) {
1297
		if (nla_put_in_addr(skb, IFLA_GENEVE_REMOTE,
1298 1299 1300 1301 1302
				    info->key.u.ipv4.dst))
			goto nla_put_failure;

		if (nla_put_u8(skb, IFLA_GENEVE_UDP_CSUM,
			       !!(info->key.tun_flags & TUNNEL_CSUM)))
1303
			goto nla_put_failure;
1304

1305 1306 1307
#if IS_ENABLED(CONFIG_IPV6)
	} else {
		if (nla_put_in6_addr(skb, IFLA_GENEVE_REMOTE6,
1308 1309 1310 1311 1312 1313 1314 1315 1316
				     &info->key.u.ipv6.dst))
			goto nla_put_failure;

		if (nla_put_u8(skb, IFLA_GENEVE_UDP_ZERO_CSUM6_TX,
			       !(info->key.tun_flags & TUNNEL_CSUM)))
			goto nla_put_failure;

		if (nla_put_u8(skb, IFLA_GENEVE_UDP_ZERO_CSUM6_RX,
			       !geneve->use_udp6_rx_checksums))
1317 1318 1319
			goto nla_put_failure;
#endif
	}
1320

1321 1322 1323
	if (nla_put_u8(skb, IFLA_GENEVE_TTL, info->key.ttl) ||
	    nla_put_u8(skb, IFLA_GENEVE_TOS, info->key.tos) ||
	    nla_put_be32(skb, IFLA_GENEVE_LABEL, info->key.label))
1324 1325
		goto nla_put_failure;

1326
	if (nla_put_be16(skb, IFLA_GENEVE_PORT, info->key.tp_dst))
1327 1328
		goto nla_put_failure;

1329 1330 1331 1332
	if (geneve->collect_md) {
		if (nla_put_flag(skb, IFLA_GENEVE_COLLECT_METADATA))
			goto nla_put_failure;
	}
1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

static struct rtnl_link_ops geneve_link_ops __read_mostly = {
	.kind		= "geneve",
	.maxtype	= IFLA_GENEVE_MAX,
	.policy		= geneve_policy,
	.priv_size	= sizeof(struct geneve_dev),
	.setup		= geneve_setup,
	.validate	= geneve_validate,
	.newlink	= geneve_newlink,
	.dellink	= geneve_dellink,
	.get_size	= geneve_get_size,
	.fill_info	= geneve_fill_info,
};

1352 1353 1354 1355
struct net_device *geneve_dev_create_fb(struct net *net, const char *name,
					u8 name_assign_type, u16 dst_port)
{
	struct nlattr *tb[IFLA_MAX + 1];
1356
	struct ip_tunnel_info info;
1357
	struct net_device *dev;
1358
	LIST_HEAD(list_kill);
1359 1360 1361 1362 1363 1364 1365 1366
	int err;

	memset(tb, 0, sizeof(tb));
	dev = rtnl_create_link(net, name, name_assign_type,
			       &geneve_link_ops, tb);
	if (IS_ERR(dev))
		return dev;

1367 1368
	init_tnl_info(&info, dst_port);
	err = geneve_configure(net, dev, &info, true, true);
1369 1370 1371 1372
	if (err) {
		free_netdev(dev);
		return ERR_PTR(err);
	}
1373 1374 1375 1376

	/* openvswitch users expect packet sizes to be unrestricted,
	 * so set the largest MTU we can.
	 */
1377
	err = geneve_change_mtu(dev, IP_MAX_MTU);
1378 1379 1380
	if (err)
		goto err;

1381 1382 1383 1384
	err = rtnl_configure_link(dev, NULL);
	if (err < 0)
		goto err;

1385
	return dev;
1386
err:
1387 1388
	geneve_dellink(dev, &list_kill);
	unregister_netdevice_many(&list_kill);
1389
	return ERR_PTR(err);
1390 1391 1392
}
EXPORT_SYMBOL_GPL(geneve_dev_create_fb);

1393 1394 1395 1396 1397
static int geneve_netdevice_event(struct notifier_block *unused,
				  unsigned long event, void *ptr)
{
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);

1398
	if (event == NETDEV_UDP_TUNNEL_PUSH_INFO)
1399 1400 1401 1402 1403 1404 1405 1406 1407
		geneve_push_rx_ports(dev);

	return NOTIFY_DONE;
}

static struct notifier_block geneve_notifier_block __read_mostly = {
	.notifier_call = geneve_netdevice_event,
};

1408 1409 1410 1411 1412
static __net_init int geneve_init_net(struct net *net)
{
	struct geneve_net *gn = net_generic(net, geneve_net_id);

	INIT_LIST_HEAD(&gn->geneve_list);
1413
	INIT_LIST_HEAD(&gn->sock_list);
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
	return 0;
}

static void __net_exit geneve_exit_net(struct net *net)
{
	struct geneve_net *gn = net_generic(net, geneve_net_id);
	struct geneve_dev *geneve, *next;
	struct net_device *dev, *aux;
	LIST_HEAD(list);

	rtnl_lock();

	/* gather any geneve devices that were moved into this ns */
	for_each_netdev_safe(net, dev, aux)
		if (dev->rtnl_link_ops == &geneve_link_ops)
			unregister_netdevice_queue(dev, &list);

	/* now gather any other geneve devices that were created in this ns */
	list_for_each_entry_safe(geneve, next, &gn->geneve_list, next) {
		/* If geneve->dev is in the same netns, it was already added
		 * to the list by the previous loop.
		 */
		if (!net_eq(dev_net(geneve->dev), net))
			unregister_netdevice_queue(geneve->dev, &list);
	}

	/* unregister the devices gathered above */
	unregister_netdevice_many(&list);
	rtnl_unlock();
}

static struct pernet_operations geneve_net_ops = {
	.init = geneve_init_net,
	.exit = geneve_exit_net,
	.id   = &geneve_net_id,
	.size = sizeof(struct geneve_net),
};

static int __init geneve_init_module(void)
{
	int rc;

	rc = register_pernet_subsys(&geneve_net_ops);
	if (rc)
		goto out1;

1460
	rc = register_netdevice_notifier(&geneve_notifier_block);
1461 1462 1463
	if (rc)
		goto out2;

1464 1465 1466 1467
	rc = rtnl_link_register(&geneve_link_ops);
	if (rc)
		goto out3;

1468
	return 0;
1469 1470
out3:
	unregister_netdevice_notifier(&geneve_notifier_block);
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
out2:
	unregister_pernet_subsys(&geneve_net_ops);
out1:
	return rc;
}
late_initcall(geneve_init_module);

static void __exit geneve_cleanup_module(void)
{
	rtnl_link_unregister(&geneve_link_ops);
1481
	unregister_netdevice_notifier(&geneve_notifier_block);
1482 1483 1484 1485 1486 1487 1488 1489 1490
	unregister_pernet_subsys(&geneve_net_ops);
}
module_exit(geneve_cleanup_module);

MODULE_LICENSE("GPL");
MODULE_VERSION(GENEVE_NETDEV_VER);
MODULE_AUTHOR("John W. Linville <linville@tuxdriver.com>");
MODULE_DESCRIPTION("Interface driver for GENEVE encapsulated traffic");
MODULE_ALIAS_RTNL_LINK("geneve");