vxlan.c 84.7 KB
Newer Older
S
stephen hemminger 已提交
1
/*
R
Rami Rosen 已提交
2
 * VXLAN: Virtual eXtensible Local Area Network
S
stephen hemminger 已提交
3
 *
4
 * Copyright (c) 2012-2013 Vyatta Inc.
S
stephen hemminger 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 *
 * 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/types.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/rculist.h>
#include <linux/netdevice.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <linux/igmp.h>
#include <linux/etherdevice.h>
#include <linux/if_ether.h>
27
#include <linux/if_vlan.h>
S
stephen hemminger 已提交
28
#include <linux/hash.h>
Y
Yan Burman 已提交
29
#include <linux/ethtool.h>
D
David Stevens 已提交
30 31
#include <net/arp.h>
#include <net/ndisc.h>
S
stephen hemminger 已提交
32
#include <net/ip.h>
33
#include <net/ip_tunnels.h>
S
stephen hemminger 已提交
34 35
#include <net/icmp.h>
#include <net/udp.h>
T
Tom Herbert 已提交
36
#include <net/udp_tunnel.h>
S
stephen hemminger 已提交
37 38 39 40 41 42
#include <net/rtnetlink.h>
#include <net/route.h>
#include <net/dsfield.h>
#include <net/inet_ecn.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
43
#include <net/vxlan.h>
44
#include <net/protocol.h>
45

C
Cong Wang 已提交
46 47 48 49
#if IS_ENABLED(CONFIG_IPV6)
#include <net/ipv6.h>
#include <net/addrconf.h>
#include <net/ip6_tunnel.h>
50
#include <net/ip6_checksum.h>
C
Cong Wang 已提交
51
#endif
T
Thomas Graf 已提交
52
#include <net/dst_metadata.h>
S
stephen hemminger 已提交
53 54 55

#define VXLAN_VERSION	"0.1"

56 57
#define PORT_HASH_BITS	8
#define PORT_HASH_SIZE  (1<<PORT_HASH_BITS)
S
stephen hemminger 已提交
58 59 60
#define FDB_AGE_DEFAULT 300 /* 5 min */
#define FDB_AGE_INTERVAL (10 * HZ)	/* rescan interval */

61 62
/* UDP port for VXLAN traffic.
 * The IANA assigned port is 4789, but the Linux default is 8472
S
Stephen Hemminger 已提交
63
 * for compatibility with early adopters.
64
 */
65 66
static unsigned short vxlan_port __read_mostly = 8472;
module_param_named(udp_port, vxlan_port, ushort, 0444);
S
stephen hemminger 已提交
67 68 69 70 71 72
MODULE_PARM_DESC(udp_port, "Destination UDP port");

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");

P
Pravin B Shelar 已提交
73
static int vxlan_net_id;
74
static struct rtnl_link_ops vxlan_link_ops;
75

76
static const u8 all_zeros_mac[ETH_ALEN + 2];
77

78
static int vxlan_sock_add(struct vxlan_dev *vxlan);
79

80 81 82 83
/* per-network namespace private data for this module */
struct vxlan_net {
	struct list_head  vxlan_list;
	struct hlist_head sock_list[PORT_HASH_SIZE];
84
	spinlock_t	  sock_lock;
85 86
};

S
stephen hemminger 已提交
87 88 89 90 91 92
/* Forwarding table entry */
struct vxlan_fdb {
	struct hlist_node hlist;	/* linked list of entries */
	struct rcu_head	  rcu;
	unsigned long	  updated;	/* jiffies */
	unsigned long	  used;
93
	struct list_head  remotes;
94
	u8		  eth_addr[ETH_ALEN];
S
stephen hemminger 已提交
95
	u16		  state;	/* see ndm_state */
96
	u8		  flags;	/* see ndm_flags */
S
stephen hemminger 已提交
97 98 99 100 101
};

/* salt for hash table */
static u32 vxlan_salt __read_mostly;

T
Thomas Graf 已提交
102 103
static inline bool vxlan_collect_metadata(struct vxlan_sock *vs)
{
104 105
	return vs->flags & VXLAN_F_COLLECT_METADATA ||
	       ip_tunnel_collect_metadata();
T
Thomas Graf 已提交
106 107
}

C
Cong Wang 已提交
108 109 110 111
#if IS_ENABLED(CONFIG_IPV6)
static inline
bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
{
J
Jiri Benc 已提交
112 113 114 115 116 117
	if (a->sa.sa_family != b->sa.sa_family)
		return false;
	if (a->sa.sa_family == AF_INET6)
		return ipv6_addr_equal(&a->sin6.sin6_addr, &b->sin6.sin6_addr);
	else
		return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
C
Cong Wang 已提交
118 119 120 121
}

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
{
J
Jiri Benc 已提交
122 123 124 125
	if (ipa->sa.sa_family == AF_INET6)
		return ipv6_addr_any(&ipa->sin6.sin6_addr);
	else
		return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
C
Cong Wang 已提交
126 127 128 129
}

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
{
J
Jiri Benc 已提交
130 131 132 133
	if (ipa->sa.sa_family == AF_INET6)
		return ipv6_addr_is_multicast(&ipa->sin6.sin6_addr);
	else
		return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
C
Cong Wang 已提交
134 135 136 137
}

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
{
J
Jiri Benc 已提交
138
	if (nla_len(nla) >= sizeof(struct in6_addr)) {
139
		ip->sin6.sin6_addr = nla_get_in6_addr(nla);
J
Jiri Benc 已提交
140 141 142
		ip->sa.sa_family = AF_INET6;
		return 0;
	} else if (nla_len(nla) >= sizeof(__be32)) {
143
		ip->sin.sin_addr.s_addr = nla_get_in_addr(nla);
J
Jiri Benc 已提交
144 145 146 147 148
		ip->sa.sa_family = AF_INET;
		return 0;
	} else {
		return -EAFNOSUPPORT;
	}
C
Cong Wang 已提交
149 150 151
}

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
J
Jiri Benc 已提交
152
			      const union vxlan_addr *ip)
C
Cong Wang 已提交
153
{
J
Jiri Benc 已提交
154
	if (ip->sa.sa_family == AF_INET6)
155
		return nla_put_in6_addr(skb, attr, &ip->sin6.sin6_addr);
J
Jiri Benc 已提交
156
	else
157
		return nla_put_in_addr(skb, attr, ip->sin.sin_addr.s_addr);
C
Cong Wang 已提交
158 159 160 161 162 163 164
}

#else /* !CONFIG_IPV6 */

static inline
bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
{
J
Jiri Benc 已提交
165
	return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
C
Cong Wang 已提交
166 167 168 169
}

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
{
J
Jiri Benc 已提交
170
	return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
C
Cong Wang 已提交
171 172 173 174
}

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
{
J
Jiri Benc 已提交
175
	return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
C
Cong Wang 已提交
176 177 178 179
}

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
{
J
Jiri Benc 已提交
180 181 182
	if (nla_len(nla) >= sizeof(struct in6_addr)) {
		return -EAFNOSUPPORT;
	} else if (nla_len(nla) >= sizeof(__be32)) {
183
		ip->sin.sin_addr.s_addr = nla_get_in_addr(nla);
J
Jiri Benc 已提交
184 185 186 187 188
		ip->sa.sa_family = AF_INET;
		return 0;
	} else {
		return -EAFNOSUPPORT;
	}
C
Cong Wang 已提交
189 190 191
}

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
J
Jiri Benc 已提交
192
			      const union vxlan_addr *ip)
C
Cong Wang 已提交
193
{
194
	return nla_put_in_addr(skb, attr, ip->sin.sin_addr.s_addr);
C
Cong Wang 已提交
195 196 197
}
#endif

198
/* Virtual Network hash table head */
199
static inline struct hlist_head *vni_head(struct vxlan_sock *vs, __be32 vni)
200
{
201
	return &vs->vni_list[hash_32((__force u32)vni, VNI_HASH_BITS)];
202 203 204 205
}

/* Socket hash table head */
static inline struct hlist_head *vs_head(struct net *net, __be16 port)
S
stephen hemminger 已提交
206 207 208
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);

209 210 211
	return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
}

212 213 214
/* First remote destination for a forwarding entry.
 * Guaranteed to be non-NULL because remotes are never deleted.
 */
215
static inline struct vxlan_rdst *first_remote_rcu(struct vxlan_fdb *fdb)
216
{
217 218 219 220 221 222
	return list_entry_rcu(fdb->remotes.next, struct vxlan_rdst, list);
}

static inline struct vxlan_rdst *first_remote_rtnl(struct vxlan_fdb *fdb)
{
	return list_first_entry(&fdb->remotes, struct vxlan_rdst, list);
223 224
}

225 226 227 228 229
/* Find VXLAN socket based on network namespace, address family and UDP port
 * and enabled unshareable flags.
 */
static struct vxlan_sock *vxlan_find_sock(struct net *net, sa_family_t family,
					  __be16 port, u32 flags)
230 231
{
	struct vxlan_sock *vs;
232 233

	flags &= VXLAN_F_RCV_FLAGS;
234 235

	hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {
236
		if (inet_sk(vs->sock->sk)->inet_sport == port &&
237
		    vxlan_get_sk_family(vs) == family &&
238
		    vs->flags == flags)
239 240 241
			return vs;
	}
	return NULL;
S
stephen hemminger 已提交
242 243
}

244
static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs, __be32 vni)
S
stephen hemminger 已提交
245 246 247
{
	struct vxlan_dev *vxlan;

248 249 250 251
	/* For flow based devices, map all packets to VNI 0 */
	if (vs->flags & VXLAN_F_COLLECT_METADATA)
		vni = 0;

252 253
	hlist_for_each_entry_rcu(vxlan, vni_head(vs, vni), hlist) {
		if (vxlan->default_dst.remote_vni == vni)
S
stephen hemminger 已提交
254 255 256 257 258 259
			return vxlan;
	}

	return NULL;
}

P
Pravin B Shelar 已提交
260
/* Look up VNI in a per net namespace table */
261
static struct vxlan_dev *vxlan_find_vni(struct net *net, __be32 vni,
262 263
					sa_family_t family, __be16 port,
					u32 flags)
P
Pravin B Shelar 已提交
264 265 266
{
	struct vxlan_sock *vs;

267
	vs = vxlan_find_sock(net, family, port, flags);
P
Pravin B Shelar 已提交
268 269 270
	if (!vs)
		return NULL;

271
	return vxlan_vs_find_vni(vs, vni);
P
Pravin B Shelar 已提交
272 273
}

S
stephen hemminger 已提交
274 275
/* Fill in neighbour message in skbuff. */
static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,
S
Stephen Hemminger 已提交
276 277 278
			  const struct vxlan_fdb *fdb,
			  u32 portid, u32 seq, int type, unsigned int flags,
			  const struct vxlan_rdst *rdst)
S
stephen hemminger 已提交
279 280 281 282 283
{
	unsigned long now = jiffies;
	struct nda_cacheinfo ci;
	struct nlmsghdr *nlh;
	struct ndmsg *ndm;
D
David Stevens 已提交
284
	bool send_ip, send_eth;
S
stephen hemminger 已提交
285 286 287 288 289 290 291

	nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
	if (nlh == NULL)
		return -EMSGSIZE;

	ndm = nlmsg_data(nlh);
	memset(ndm, 0, sizeof(*ndm));
D
David Stevens 已提交
292 293 294 295 296

	send_eth = send_ip = true;

	if (type == RTM_GETNEIGH) {
		ndm->ndm_family	= AF_INET;
C
Cong Wang 已提交
297
		send_ip = !vxlan_addr_any(&rdst->remote_ip);
D
David Stevens 已提交
298 299 300
		send_eth = !is_zero_ether_addr(fdb->eth_addr);
	} else
		ndm->ndm_family	= AF_BRIDGE;
S
stephen hemminger 已提交
301 302
	ndm->ndm_state = fdb->state;
	ndm->ndm_ifindex = vxlan->dev->ifindex;
303
	ndm->ndm_flags = fdb->flags;
304
	ndm->ndm_type = RTN_UNICAST;
S
stephen hemminger 已提交
305

306
	if (!net_eq(dev_net(vxlan->dev), vxlan->net) &&
307
	    nla_put_s32(skb, NDA_LINK_NETNSID,
308
			peernet2id_alloc(dev_net(vxlan->dev), vxlan->net)))
309 310
		goto nla_put_failure;

D
David Stevens 已提交
311
	if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))
S
stephen hemminger 已提交
312 313
		goto nla_put_failure;

C
Cong Wang 已提交
314
	if (send_ip && vxlan_nla_put_addr(skb, NDA_DST, &rdst->remote_ip))
315 316
		goto nla_put_failure;

317
	if (rdst->remote_port && rdst->remote_port != vxlan->cfg.dst_port &&
318 319
	    nla_put_be16(skb, NDA_PORT, rdst->remote_port))
		goto nla_put_failure;
320
	if (rdst->remote_vni != vxlan->default_dst.remote_vni &&
321
	    nla_put_u32(skb, NDA_VNI, be32_to_cpu(rdst->remote_vni)))
322 323 324
		goto nla_put_failure;
	if (rdst->remote_ifindex &&
	    nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
S
stephen hemminger 已提交
325 326 327 328 329 330 331 332 333 334
		goto nla_put_failure;

	ci.ndm_used	 = jiffies_to_clock_t(now - fdb->used);
	ci.ndm_confirmed = 0;
	ci.ndm_updated	 = jiffies_to_clock_t(now - fdb->updated);
	ci.ndm_refcnt	 = 0;

	if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
		goto nla_put_failure;

335 336
	nlmsg_end(skb, nlh);
	return 0;
S
stephen hemminger 已提交
337 338 339 340 341 342 343 344 345 346

nla_put_failure:
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
}

static inline size_t vxlan_nlmsg_size(void)
{
	return NLMSG_ALIGN(sizeof(struct ndmsg))
		+ nla_total_size(ETH_ALEN) /* NDA_LLADDR */
C
Cong Wang 已提交
347
		+ nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */
348
		+ nla_total_size(sizeof(__be16)) /* NDA_PORT */
349 350
		+ nla_total_size(sizeof(__be32)) /* NDA_VNI */
		+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
351
		+ nla_total_size(sizeof(__s32)) /* NDA_LINK_NETNSID */
S
stephen hemminger 已提交
352 353 354
		+ nla_total_size(sizeof(struct nda_cacheinfo));
}

355 356
static void vxlan_fdb_notify(struct vxlan_dev *vxlan, struct vxlan_fdb *fdb,
			     struct vxlan_rdst *rd, int type)
S
stephen hemminger 已提交
357 358 359 360 361 362 363 364 365
{
	struct net *net = dev_net(vxlan->dev);
	struct sk_buff *skb;
	int err = -ENOBUFS;

	skb = nlmsg_new(vxlan_nlmsg_size(), GFP_ATOMIC);
	if (skb == NULL)
		goto errout;

366
	err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0, rd);
S
stephen hemminger 已提交
367 368 369 370 371 372 373 374 375 376 377 378 379 380
	if (err < 0) {
		/* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}

	rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
	return;
errout:
	if (err < 0)
		rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
}

C
Cong Wang 已提交
381
static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)
D
David Stevens 已提交
382 383
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
384 385 386 387
	struct vxlan_fdb f = {
		.state = NUD_STALE,
	};
	struct vxlan_rdst remote = {
C
Cong Wang 已提交
388
		.remote_ip = *ipa, /* goes to NDA_DST */
389
		.remote_vni = cpu_to_be32(VXLAN_N_VID),
390
	};
391

392
	vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH);
D
David Stevens 已提交
393 394 395 396
}

static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])
{
397 398 399
	struct vxlan_fdb f = {
		.state = NUD_STALE,
	};
400
	struct vxlan_rdst remote = { };
D
David Stevens 已提交
401 402 403

	memcpy(f.eth_addr, eth_addr, ETH_ALEN);

404
	vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH);
D
David Stevens 已提交
405 406
}

S
stephen hemminger 已提交
407 408 409 410 411 412 413 414
/* Hash Ethernet address */
static u32 eth_hash(const unsigned char *addr)
{
	u64 value = get_unaligned((u64 *)addr);

	/* only want 6 bytes */
#ifdef __BIG_ENDIAN
	value >>= 16;
415 416
#else
	value <<= 16;
S
stephen hemminger 已提交
417 418 419 420 421 422 423 424 425 426 427 428
#endif
	return hash_64(value, FDB_HASH_BITS);
}

/* Hash chain to use given mac address */
static inline struct hlist_head *vxlan_fdb_head(struct vxlan_dev *vxlan,
						const u8 *mac)
{
	return &vxlan->fdb_head[eth_hash(mac)];
}

/* Look up Ethernet address in forwarding table */
429
static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,
S
stephen hemminger 已提交
430 431 432 433 434
					const u8 *mac)
{
	struct hlist_head *head = vxlan_fdb_head(vxlan, mac);
	struct vxlan_fdb *f;

435
	hlist_for_each_entry_rcu(f, head, hlist) {
436
		if (ether_addr_equal(mac, f->eth_addr))
S
stephen hemminger 已提交
437 438 439 440 441 442
			return f;
	}

	return NULL;
}

443 444 445 446 447 448 449 450 451 452 453 454
static struct vxlan_fdb *vxlan_find_mac(struct vxlan_dev *vxlan,
					const u8 *mac)
{
	struct vxlan_fdb *f;

	f = __vxlan_find_mac(vxlan, mac);
	if (f)
		f->used = jiffies;

	return f;
}

455 456
/* caller should hold vxlan->hash_lock */
static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,
C
Cong Wang 已提交
457
					      union vxlan_addr *ip, __be16 port,
458
					      __be32 vni, __u32 ifindex)
459
{
460
	struct vxlan_rdst *rd;
461

462
	list_for_each_entry(rd, &f->remotes, list) {
C
Cong Wang 已提交
463
		if (vxlan_addr_equal(&rd->remote_ip, ip) &&
464 465 466
		    rd->remote_port == port &&
		    rd->remote_vni == vni &&
		    rd->remote_ifindex == ifindex)
467
			return rd;
468
	}
469

470 471 472
	return NULL;
}

473 474
/* Replace destination of unicast mac */
static int vxlan_fdb_replace(struct vxlan_fdb *f,
475 476
			     union vxlan_addr *ip, __be16 port, __be32 vni,
			     __u32 ifindex)
477 478 479 480 481 482 483 484 485 486
{
	struct vxlan_rdst *rd;

	rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
	if (rd)
		return 0;

	rd = list_first_entry_or_null(&f->remotes, struct vxlan_rdst, list);
	if (!rd)
		return 0;
487 488

	dst_cache_reset(&rd->dst_cache);
C
Cong Wang 已提交
489
	rd->remote_ip = *ip;
490 491 492 493 494 495
	rd->remote_port = port;
	rd->remote_vni = vni;
	rd->remote_ifindex = ifindex;
	return 1;
}

496 497
/* Add/update destinations for multicast */
static int vxlan_fdb_append(struct vxlan_fdb *f,
498
			    union vxlan_addr *ip, __be16 port, __be32 vni,
499
			    __u32 ifindex, struct vxlan_rdst **rdp)
500 501 502 503 504 505 506
{
	struct vxlan_rdst *rd;

	rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
	if (rd)
		return 0;

507 508 509
	rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
	if (rd == NULL)
		return -ENOBUFS;
510 511 512 513 514 515

	if (dst_cache_init(&rd->dst_cache, GFP_ATOMIC)) {
		kfree(rd);
		return -ENOBUFS;
	}

C
Cong Wang 已提交
516
	rd->remote_ip = *ip;
517 518 519
	rd->remote_port = port;
	rd->remote_vni = vni;
	rd->remote_ifindex = ifindex;
520 521 522

	list_add_tail_rcu(&rd->list, &f->remotes);

523
	*rdp = rd;
524 525 526
	return 1;
}

T
Tom Herbert 已提交
527 528 529
static struct vxlanhdr *vxlan_gro_remcsum(struct sk_buff *skb,
					  unsigned int off,
					  struct vxlanhdr *vh, size_t hdrlen,
530 531
					  __be32 vni_field,
					  struct gro_remcsum *grc,
532
					  bool nopartial)
T
Tom Herbert 已提交
533
{
534
	size_t start, offset;
T
Tom Herbert 已提交
535 536

	if (skb->remcsum_offload)
537
		return vh;
T
Tom Herbert 已提交
538 539 540 541

	if (!NAPI_GRO_CB(skb)->csum_valid)
		return NULL;

542 543
	start = vxlan_rco_start(vni_field);
	offset = start + vxlan_rco_offset(vni_field);
T
Tom Herbert 已提交
544

545 546
	vh = skb_gro_remcsum_process(skb, (void *)vh, off, hdrlen,
				     start, offset, grc, nopartial);
T
Tom Herbert 已提交
547 548 549 550 551 552

	skb->remcsum_offload = 1;

	return vh;
}

553 554 555
static struct sk_buff **vxlan_gro_receive(struct sock *sk,
					  struct sk_buff **head,
					  struct sk_buff *skb)
556 557 558
{
	struct sk_buff *p, **pp = NULL;
	struct vxlanhdr *vh, *vh2;
559
	unsigned int hlen, off_vx;
560
	int flush = 1;
561
	struct vxlan_sock *vs = rcu_dereference_sk_user_data(sk);
562
	__be32 flags;
563 564 565
	struct gro_remcsum grc;

	skb_gro_remcsum_init(&grc);
566 567 568 569 570 571 572 573 574 575

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

T
Tom Herbert 已提交
576 577
	skb_gro_postpull_rcsum(skb, vh, sizeof(struct vxlanhdr));

578
	flags = vh->vx_flags;
T
Tom Herbert 已提交
579 580 581

	if ((flags & VXLAN_HF_RCO) && (vs->flags & VXLAN_F_REMCSUM_RX)) {
		vh = vxlan_gro_remcsum(skb, off_vx, vh, sizeof(struct vxlanhdr),
582
				       vh->vx_vni, &grc,
583 584
				       !!(vs->flags &
					  VXLAN_F_REMCSUM_NOPARTIAL));
T
Tom Herbert 已提交
585 586 587 588 589

		if (!vh)
			goto out;
	}

590 591
	skb_gro_pull(skb, sizeof(struct vxlanhdr)); /* pull vxlan header */

592 593 594 595 596
	for (p = *head; p; p = p->next) {
		if (!NAPI_GRO_CB(p)->same_flow)
			continue;

		vh2 = (struct vxlanhdr *)(p->data + off_vx);
T
Thomas Graf 已提交
597 598
		if (vh->vx_flags != vh2->vx_flags ||
		    vh->vx_vni != vh2->vx_vni) {
599 600 601 602 603
			NAPI_GRO_CB(p)->same_flow = 0;
			continue;
		}
	}

604
	pp = eth_gro_receive(head, skb);
605
	flush = 0;
606 607

out:
608
	skb_gro_remcsum_cleanup(skb, &grc);
609 610 611 612 613
	NAPI_GRO_CB(skb)->flush |= flush;

	return pp;
}

614
static int vxlan_gro_complete(struct sock *sk, struct sk_buff *skb, int nhoff)
615
{
616 617 618
	/* Sets 'skb->inner_mac_header' since we are always called with
	 * 'skb->encapsulation' set.
	 */
619
	return eth_gro_complete(skb, nhoff + sizeof(struct vxlanhdr));
620 621
}

622
/* Notify netdevs that UDP port started listening */
623
static void vxlan_notify_add_rx_port(struct vxlan_sock *vs)
624 625
{
	struct net_device *dev;
626
	struct sock *sk = vs->sock->sk;
627
	struct net *net = sock_net(sk);
628
	sa_family_t sa_family = vxlan_get_sk_family(vs);
J
Joseph Gasparakis 已提交
629
	__be16 port = inet_sk(sk)->inet_sport;
630 631 632 633 634 635 636 637 638 639 640

	rcu_read_lock();
	for_each_netdev_rcu(net, dev) {
		if (dev->netdev_ops->ndo_add_vxlan_port)
			dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,
							    port);
	}
	rcu_read_unlock();
}

/* Notify netdevs that UDP port is no more listening */
641
static void vxlan_notify_del_rx_port(struct vxlan_sock *vs)
642 643
{
	struct net_device *dev;
644
	struct sock *sk = vs->sock->sk;
645
	struct net *net = sock_net(sk);
646
	sa_family_t sa_family = vxlan_get_sk_family(vs);
J
Joseph Gasparakis 已提交
647
	__be16 port = inet_sk(sk)->inet_sport;
648 649 650 651 652 653 654 655 656 657

	rcu_read_lock();
	for_each_netdev_rcu(net, dev) {
		if (dev->netdev_ops->ndo_del_vxlan_port)
			dev->netdev_ops->ndo_del_vxlan_port(dev, sa_family,
							    port);
	}
	rcu_read_unlock();
}

S
stephen hemminger 已提交
658 659
/* Add new entry to forwarding table -- assumes lock held */
static int vxlan_fdb_create(struct vxlan_dev *vxlan,
C
Cong Wang 已提交
660
			    const u8 *mac, union vxlan_addr *ip,
661
			    __u16 state, __u16 flags,
662
			    __be16 port, __be32 vni, __u32 ifindex,
663
			    __u8 ndm_flags)
S
stephen hemminger 已提交
664
{
665
	struct vxlan_rdst *rd = NULL;
S
stephen hemminger 已提交
666 667 668
	struct vxlan_fdb *f;
	int notify = 0;

669
	f = __vxlan_find_mac(vxlan, mac);
S
stephen hemminger 已提交
670 671 672 673 674 675 676 677 678 679 680
	if (f) {
		if (flags & NLM_F_EXCL) {
			netdev_dbg(vxlan->dev,
				   "lost race to create %pM\n", mac);
			return -EEXIST;
		}
		if (f->state != state) {
			f->state = state;
			f->updated = jiffies;
			notify = 1;
		}
681 682 683 684 685
		if (f->flags != ndm_flags) {
			f->flags = ndm_flags;
			f->updated = jiffies;
			notify = 1;
		}
686 687 688 689
		if ((flags & NLM_F_REPLACE)) {
			/* Only change unicasts */
			if (!(is_multicast_ether_addr(f->eth_addr) ||
			     is_zero_ether_addr(f->eth_addr))) {
690
				notify |= vxlan_fdb_replace(f, ip, port, vni,
691 692 693 694
							   ifindex);
			} else
				return -EOPNOTSUPP;
		}
695
		if ((flags & NLM_F_APPEND) &&
696 697
		    (is_multicast_ether_addr(f->eth_addr) ||
		     is_zero_ether_addr(f->eth_addr))) {
698 699
			int rc = vxlan_fdb_append(f, ip, port, vni, ifindex,
						  &rd);
700 701 702 703 704

			if (rc < 0)
				return rc;
			notify |= rc;
		}
S
stephen hemminger 已提交
705 706 707 708
	} else {
		if (!(flags & NLM_F_CREATE))
			return -ENOENT;

709 710
		if (vxlan->cfg.addrmax &&
		    vxlan->addrcnt >= vxlan->cfg.addrmax)
S
stephen hemminger 已提交
711 712
			return -ENOSPC;

713 714 715 716 717
		/* Disallow replace to add a multicast entry */
		if ((flags & NLM_F_REPLACE) &&
		    (is_multicast_ether_addr(mac) || is_zero_ether_addr(mac)))
			return -EOPNOTSUPP;

C
Cong Wang 已提交
718
		netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);
S
stephen hemminger 已提交
719 720 721 722 723 724
		f = kmalloc(sizeof(*f), GFP_ATOMIC);
		if (!f)
			return -ENOMEM;

		notify = 1;
		f->state = state;
725
		f->flags = ndm_flags;
S
stephen hemminger 已提交
726
		f->updated = f->used = jiffies;
727
		INIT_LIST_HEAD(&f->remotes);
S
stephen hemminger 已提交
728 729
		memcpy(f->eth_addr, mac, ETH_ALEN);

730
		vxlan_fdb_append(f, ip, port, vni, ifindex, &rd);
731

S
stephen hemminger 已提交
732 733 734 735 736
		++vxlan->addrcnt;
		hlist_add_head_rcu(&f->hlist,
				   vxlan_fdb_head(vxlan, mac));
	}

737 738 739 740 741
	if (notify) {
		if (rd == NULL)
			rd = first_remote_rtnl(f);
		vxlan_fdb_notify(vxlan, f, rd, RTM_NEWNEIGH);
	}
S
stephen hemminger 已提交
742 743 744 745

	return 0;
}

W
Wei Yongjun 已提交
746
static void vxlan_fdb_free(struct rcu_head *head)
747 748
{
	struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);
749
	struct vxlan_rdst *rd, *nd;
750

751 752
	list_for_each_entry_safe(rd, nd, &f->remotes, list) {
		dst_cache_destroy(&rd->dst_cache);
753
		kfree(rd);
754
	}
755 756 757
	kfree(f);
}

S
stephen hemminger 已提交
758 759 760 761 762 763
static void vxlan_fdb_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f)
{
	netdev_dbg(vxlan->dev,
		    "delete %pM\n", f->eth_addr);

	--vxlan->addrcnt;
764
	vxlan_fdb_notify(vxlan, f, first_remote_rtnl(f), RTM_DELNEIGH);
S
stephen hemminger 已提交
765 766

	hlist_del_rcu(&f->hlist);
767
	call_rcu(&f->rcu, vxlan_fdb_free);
S
stephen hemminger 已提交
768 769
}

M
Mike Rapoport 已提交
770
static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,
771 772
			   union vxlan_addr *ip, __be16 *port, __be32 *vni,
			   u32 *ifindex)
S
stephen hemminger 已提交
773
{
774
	struct net *net = dev_net(vxlan->dev);
C
Cong Wang 已提交
775
	int err;
S
stephen hemminger 已提交
776

M
Mike Rapoport 已提交
777
	if (tb[NDA_DST]) {
C
Cong Wang 已提交
778 779 780
		err = vxlan_nla_get_addr(ip, tb[NDA_DST]);
		if (err)
			return err;
M
Mike Rapoport 已提交
781
	} else {
C
Cong Wang 已提交
782 783 784 785 786 787 788 789 790 791
		union vxlan_addr *remote = &vxlan->default_dst.remote_ip;
		if (remote->sa.sa_family == AF_INET) {
			ip->sin.sin_addr.s_addr = htonl(INADDR_ANY);
			ip->sa.sa_family = AF_INET;
#if IS_ENABLED(CONFIG_IPV6)
		} else {
			ip->sin6.sin6_addr = in6addr_any;
			ip->sa.sa_family = AF_INET6;
#endif
		}
M
Mike Rapoport 已提交
792
	}
S
stephen hemminger 已提交
793

794
	if (tb[NDA_PORT]) {
795
		if (nla_len(tb[NDA_PORT]) != sizeof(__be16))
796
			return -EINVAL;
M
Mike Rapoport 已提交
797 798
		*port = nla_get_be16(tb[NDA_PORT]);
	} else {
799
		*port = vxlan->cfg.dst_port;
M
Mike Rapoport 已提交
800
	}
801 802 803 804

	if (tb[NDA_VNI]) {
		if (nla_len(tb[NDA_VNI]) != sizeof(u32))
			return -EINVAL;
805
		*vni = cpu_to_be32(nla_get_u32(tb[NDA_VNI]));
M
Mike Rapoport 已提交
806 807 808
	} else {
		*vni = vxlan->default_dst.remote_vni;
	}
809 810

	if (tb[NDA_IFINDEX]) {
P
Pravin B Shelar 已提交
811
		struct net_device *tdev;
812 813 814

		if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
			return -EINVAL;
M
Mike Rapoport 已提交
815
		*ifindex = nla_get_u32(tb[NDA_IFINDEX]);
816
		tdev = __dev_get_by_index(net, *ifindex);
P
Pravin B Shelar 已提交
817
		if (!tdev)
818
			return -EADDRNOTAVAIL;
M
Mike Rapoport 已提交
819 820 821 822 823 824 825 826 827 828
	} else {
		*ifindex = 0;
	}

	return 0;
}

/* Add static entry (via netlink) */
static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
			 struct net_device *dev,
829
			 const unsigned char *addr, u16 vid, u16 flags)
M
Mike Rapoport 已提交
830 831 832
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	/* struct net *net = dev_net(vxlan->dev); */
C
Cong Wang 已提交
833
	union vxlan_addr ip;
M
Mike Rapoport 已提交
834
	__be16 port;
835 836
	__be32 vni;
	u32 ifindex;
M
Mike Rapoport 已提交
837 838 839 840 841 842 843 844 845 846 847 848 849 850
	int err;

	if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_REACHABLE))) {
		pr_info("RTM_NEWNEIGH with invalid state %#x\n",
			ndm->ndm_state);
		return -EINVAL;
	}

	if (tb[NDA_DST] == NULL)
		return -EINVAL;

	err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);
	if (err)
		return err;
851

852 853 854
	if (vxlan->default_dst.remote_ip.sa.sa_family != ip.sa.sa_family)
		return -EAFNOSUPPORT;

S
stephen hemminger 已提交
855
	spin_lock_bh(&vxlan->hash_lock);
C
Cong Wang 已提交
856
	err = vxlan_fdb_create(vxlan, addr, &ip, ndm->ndm_state, flags,
857
			       port, vni, ifindex, ndm->ndm_flags);
S
stephen hemminger 已提交
858 859 860 861 862 863
	spin_unlock_bh(&vxlan->hash_lock);

	return err;
}

/* Delete entry (via netlink) */
864 865
static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
			    struct net_device *dev,
866
			    const unsigned char *addr, u16 vid)
S
stephen hemminger 已提交
867 868 869
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb *f;
870
	struct vxlan_rdst *rd = NULL;
C
Cong Wang 已提交
871
	union vxlan_addr ip;
872
	__be16 port;
873 874
	__be32 vni;
	u32 ifindex;
875 876 877 878 879 880 881
	int err;

	err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);
	if (err)
		return err;

	err = -ENOENT;
S
stephen hemminger 已提交
882 883 884

	spin_lock_bh(&vxlan->hash_lock);
	f = vxlan_find_mac(vxlan, addr);
885 886 887
	if (!f)
		goto out;

C
Cong Wang 已提交
888 889
	if (!vxlan_addr_any(&ip)) {
		rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);
890 891 892 893 894 895 896 897 898 899 900
		if (!rd)
			goto out;
	}

	err = 0;

	/* remove a destination if it's not the only one on the list,
	 * otherwise destroy the fdb entry
	 */
	if (rd && !list_is_singular(&f->remotes)) {
		list_del_rcu(&rd->list);
901
		vxlan_fdb_notify(vxlan, f, rd, RTM_DELNEIGH);
902
		kfree_rcu(rd, rcu);
903
		goto out;
S
stephen hemminger 已提交
904
	}
905 906 907 908

	vxlan_fdb_destroy(vxlan, f);

out:
S
stephen hemminger 已提交
909 910 911 912 913 914 915
	spin_unlock_bh(&vxlan->hash_lock);

	return err;
}

/* Dump forwarding table */
static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
916 917
			  struct net_device *dev,
			  struct net_device *filter_dev, int idx)
S
stephen hemminger 已提交
918 919 920 921 922 923 924 925
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	unsigned int h;

	for (h = 0; h < FDB_HASH_SIZE; ++h) {
		struct vxlan_fdb *f;
		int err;

926
		hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
927 928
			struct vxlan_rdst *rd;

929
			list_for_each_entry_rcu(rd, &f->remotes, list) {
930 931 932
				if (idx < cb->args[0])
					goto skip;

933 934 935 936 937
				err = vxlan_fdb_info(skb, vxlan, f,
						     NETLINK_CB(cb->skb).portid,
						     cb->nlh->nlmsg_seq,
						     RTM_NEWNEIGH,
						     NLM_F_MULTI, rd);
938 939
				if (err < 0) {
					cb->args[1] = err;
940
					goto out;
941
				}
942
skip:
943 944
				++idx;
			}
S
stephen hemminger 已提交
945 946
		}
	}
947
out:
S
stephen hemminger 已提交
948 949 950 951 952
	return idx;
}

/* Watch incoming packets to learn mapping between Ethernet address
 * and Tunnel endpoint.
953
 * Return true if packet is bogus and should be dropped.
S
stephen hemminger 已提交
954
 */
955
static bool vxlan_snoop(struct net_device *dev,
C
Cong Wang 已提交
956
			union vxlan_addr *src_ip, const u8 *src_mac)
S
stephen hemminger 已提交
957 958 959 960 961 962
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb *f;

	f = vxlan_find_mac(vxlan, src_mac);
	if (likely(f)) {
963
		struct vxlan_rdst *rdst = first_remote_rcu(f);
964

C
Cong Wang 已提交
965
		if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip)))
966 967 968
			return false;

		/* Don't migrate static entries, drop packets */
969
		if (f->state & NUD_NOARP)
970
			return true;
S
stephen hemminger 已提交
971 972 973

		if (net_ratelimit())
			netdev_info(dev,
C
Cong Wang 已提交
974
				    "%pM migrated from %pIS to %pIS\n",
975
				    src_mac, &rdst->remote_ip.sa, &src_ip->sa);
S
stephen hemminger 已提交
976

C
Cong Wang 已提交
977
		rdst->remote_ip = *src_ip;
S
stephen hemminger 已提交
978
		f->updated = jiffies;
979
		vxlan_fdb_notify(vxlan, f, rdst, RTM_NEWNEIGH);
S
stephen hemminger 已提交
980 981 982
	} else {
		/* learned new entry */
		spin_lock(&vxlan->hash_lock);
983 984 985 986 987 988

		/* close off race between vxlan_flush and incoming packets */
		if (netif_running(dev))
			vxlan_fdb_create(vxlan, src_mac, src_ip,
					 NUD_REACHABLE,
					 NLM_F_EXCL|NLM_F_CREATE,
989
					 vxlan->cfg.dst_port,
990 991
					 vxlan->default_dst.remote_vni,
					 0, NTF_SELF);
S
stephen hemminger 已提交
992 993
		spin_unlock(&vxlan->hash_lock);
	}
994 995

	return false;
S
stephen hemminger 已提交
996 997 998
}

/* See if multicast group is already in use by other ID */
999
static bool vxlan_group_used(struct vxlan_net *vn, struct vxlan_dev *dev)
S
stephen hemminger 已提交
1000
{
1001
	struct vxlan_dev *vxlan;
1002
	unsigned short family = dev->default_dst.remote_ip.sa.sa_family;
S
stephen hemminger 已提交
1003

1004 1005 1006
	/* The vxlan_sock is only used by dev, leaving group has
	 * no effect on other vxlan devices.
	 */
1007 1008
	if (family == AF_INET && dev->vn4_sock &&
	    atomic_read(&dev->vn4_sock->refcnt) == 1)
1009
		return false;
1010 1011 1012 1013 1014
#if IS_ENABLED(CONFIG_IPV6)
	if (family == AF_INET6 && dev->vn6_sock &&
	    atomic_read(&dev->vn6_sock->refcnt) == 1)
		return false;
#endif
1015

1016
	list_for_each_entry(vxlan, &vn->vxlan_list, next) {
1017
		if (!netif_running(vxlan->dev) || vxlan == dev)
1018
			continue;
S
stephen hemminger 已提交
1019

1020
		if (family == AF_INET && vxlan->vn4_sock != dev->vn4_sock)
1021
			continue;
1022 1023 1024 1025
#if IS_ENABLED(CONFIG_IPV6)
		if (family == AF_INET6 && vxlan->vn6_sock != dev->vn6_sock)
			continue;
#endif
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035

		if (!vxlan_addr_equal(&vxlan->default_dst.remote_ip,
				      &dev->default_dst.remote_ip))
			continue;

		if (vxlan->default_dst.remote_ifindex !=
		    dev->default_dst.remote_ifindex)
			continue;

		return true;
1036
	}
S
stephen hemminger 已提交
1037 1038 1039 1040

	return false;
}

1041
static bool __vxlan_sock_release_prep(struct vxlan_sock *vs)
1042
{
1043
	struct vxlan_net *vn;
1044

1045
	if (!vs)
1046
		return false;
1047
	if (!atomic_dec_and_test(&vs->refcnt))
1048
		return false;
S
stephen hemminger 已提交
1049

1050
	vn = net_generic(sock_net(vs->sock->sk), vxlan_net_id);
1051
	spin_lock(&vn->sock_lock);
1052
	hlist_del_rcu(&vs->hlist);
1053
	vxlan_notify_del_rx_port(vs);
1054 1055
	spin_unlock(&vn->sock_lock);

1056
	return true;
S
stephen hemminger 已提交
1057 1058
}

1059 1060
static void vxlan_sock_release(struct vxlan_dev *vxlan)
{
1061
	bool ipv4 = __vxlan_sock_release_prep(vxlan->vn4_sock);
1062
#if IS_ENABLED(CONFIG_IPV6)
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
	bool ipv6 = __vxlan_sock_release_prep(vxlan->vn6_sock);
#endif

	synchronize_net();

	if (ipv4) {
		udp_tunnel_sock_release(vxlan->vn4_sock->sock);
		kfree(vxlan->vn4_sock);
	}

#if IS_ENABLED(CONFIG_IPV6)
	if (ipv6) {
		udp_tunnel_sock_release(vxlan->vn6_sock->sock);
		kfree(vxlan->vn6_sock);
	}
1078 1079 1080
#endif
}

1081
/* Update multicast group membership when first VNI on
1082
 * multicast address is brought up
1083
 */
1084
static int vxlan_igmp_join(struct vxlan_dev *vxlan)
S
stephen hemminger 已提交
1085
{
1086
	struct sock *sk;
C
Cong Wang 已提交
1087 1088
	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
	int ifindex = vxlan->default_dst.remote_ifindex;
1089
	int ret = -EINVAL;
S
stephen hemminger 已提交
1090

C
Cong Wang 已提交
1091 1092 1093 1094 1095 1096
	if (ip->sa.sa_family == AF_INET) {
		struct ip_mreqn mreq = {
			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
			.imr_ifindex		= ifindex,
		};

1097 1098
		sk = vxlan->vn4_sock->sock->sk;
		lock_sock(sk);
1099
		ret = ip_mc_join_group(sk, &mreq);
1100
		release_sock(sk);
C
Cong Wang 已提交
1101 1102
#if IS_ENABLED(CONFIG_IPV6)
	} else {
1103 1104
		sk = vxlan->vn6_sock->sock->sk;
		lock_sock(sk);
1105 1106
		ret = ipv6_stub->ipv6_sock_mc_join(sk, ifindex,
						   &ip->sin6.sin6_addr);
1107
		release_sock(sk);
C
Cong Wang 已提交
1108 1109
#endif
	}
S
stephen hemminger 已提交
1110

1111
	return ret;
S
stephen hemminger 已提交
1112 1113 1114
}

/* Inverse of vxlan_igmp_join when last VNI is brought down */
1115
static int vxlan_igmp_leave(struct vxlan_dev *vxlan)
S
stephen hemminger 已提交
1116
{
1117
	struct sock *sk;
C
Cong Wang 已提交
1118 1119
	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
	int ifindex = vxlan->default_dst.remote_ifindex;
1120
	int ret = -EINVAL;
S
stephen hemminger 已提交
1121

C
Cong Wang 已提交
1122 1123 1124 1125 1126 1127
	if (ip->sa.sa_family == AF_INET) {
		struct ip_mreqn mreq = {
			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
			.imr_ifindex		= ifindex,
		};

1128 1129
		sk = vxlan->vn4_sock->sock->sk;
		lock_sock(sk);
1130
		ret = ip_mc_leave_group(sk, &mreq);
1131
		release_sock(sk);
C
Cong Wang 已提交
1132 1133
#if IS_ENABLED(CONFIG_IPV6)
	} else {
1134 1135
		sk = vxlan->vn6_sock->sock->sk;
		lock_sock(sk);
1136 1137
		ret = ipv6_stub->ipv6_sock_mc_drop(sk, ifindex,
						   &ip->sin6.sin6_addr);
1138
		release_sock(sk);
C
Cong Wang 已提交
1139 1140
#endif
	}
S
stephen hemminger 已提交
1141

1142
	return ret;
S
stephen hemminger 已提交
1143 1144
}

1145 1146
static bool vxlan_remcsum(struct vxlanhdr *unparsed,
			  struct sk_buff *skb, u32 vxflags)
T
Tom Herbert 已提交
1147
{
1148
	size_t start, offset;
T
Tom Herbert 已提交
1149

1150 1151
	if (!(unparsed->vx_flags & VXLAN_HF_RCO) || skb->remcsum_offload)
		goto out;
1152

1153 1154
	start = vxlan_rco_start(unparsed->vx_vni);
	offset = start + vxlan_rco_offset(unparsed->vx_vni);
T
Tom Herbert 已提交
1155

1156
	if (!pskb_may_pull(skb, offset + sizeof(u16)))
J
Jiri Benc 已提交
1157
		return false;
T
Tom Herbert 已提交
1158

J
Jiri Benc 已提交
1159 1160
	skb_remcsum_process(skb, (void *)(vxlan_hdr(skb) + 1), start, offset,
			    !!(vxflags & VXLAN_F_REMCSUM_NOPARTIAL));
1161 1162 1163
out:
	unparsed->vx_flags &= ~VXLAN_HF_RCO;
	unparsed->vx_vni &= VXLAN_VNI_MASK;
J
Jiri Benc 已提交
1164
	return true;
T
Tom Herbert 已提交
1165 1166
}

1167
static void vxlan_parse_gbp_hdr(struct vxlanhdr *unparsed,
1168
				struct sk_buff *skb, u32 vxflags,
1169
				struct vxlan_metadata *md)
1170
{
1171
	struct vxlanhdr_gbp *gbp = (struct vxlanhdr_gbp *)unparsed;
1172
	struct metadata_dst *tun_dst;
1173 1174 1175

	if (!(unparsed->vx_flags & VXLAN_HF_GBP))
		goto out;
1176 1177 1178

	md->gbp = ntohs(gbp->policy_id);

1179
	tun_dst = (struct metadata_dst *)skb_dst(skb);
1180
	if (tun_dst) {
1181
		tun_dst->u.tun_info.key.tun_flags |= TUNNEL_VXLAN_OPT;
1182 1183
		tun_dst->u.tun_info.options_len = sizeof(*md);
	}
1184 1185 1186 1187 1188
	if (gbp->dont_learn)
		md->gbp |= VXLAN_GBP_DONT_LEARN;

	if (gbp->policy_applied)
		md->gbp |= VXLAN_GBP_POLICY_APPLIED;
1189

1190 1191 1192
	/* In flow-based mode, GBP is carried in dst_metadata */
	if (!(vxflags & VXLAN_F_COLLECT_METADATA))
		skb->mark = md->gbp;
1193 1194
out:
	unparsed->vx_flags &= ~VXLAN_GBP_USED_BITS;
1195 1196
}

J
Jiri Benc 已提交
1197
static bool vxlan_parse_gpe_hdr(struct vxlanhdr *unparsed,
J
Jiri Benc 已提交
1198
				__be16 *protocol,
J
Jiri Benc 已提交
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
				struct sk_buff *skb, u32 vxflags)
{
	struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)unparsed;

	/* Need to have Next Protocol set for interfaces in GPE mode. */
	if (!gpe->np_applied)
		return false;
	/* "The initial version is 0. If a receiver does not support the
	 * version indicated it MUST drop the packet.
	 */
	if (gpe->version != 0)
		return false;
	/* "When the O bit is set to 1, the packet is an OAM packet and OAM
	 * processing MUST occur." However, we don't implement OAM
	 * processing, thus drop the packet.
	 */
	if (gpe->oam_flag)
		return false;

	switch (gpe->next_protocol) {
	case VXLAN_GPE_NP_IPV4:
		*protocol = htons(ETH_P_IP);
		break;
	case VXLAN_GPE_NP_IPV6:
		*protocol = htons(ETH_P_IPV6);
		break;
	case VXLAN_GPE_NP_ETHERNET:
		*protocol = htons(ETH_P_TEB);
		break;
	default:
		return false;
	}

	unparsed->vx_flags &= ~VXLAN_GPE_USED_BITS;
	return true;
}

1236 1237 1238
static bool vxlan_set_mac(struct vxlan_dev *vxlan,
			  struct vxlan_sock *vs,
			  struct sk_buff *skb)
1239 1240 1241 1242 1243 1244 1245 1246 1247
{
	union vxlan_addr saddr;

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

	/* Ignore packet loops (and multicast echo) */
	if (ether_addr_equal(eth_hdr(skb)->h_source, vxlan->dev->dev_addr))
1248
		return false;
1249

1250
	/* Get address from the outer IP header */
1251
	if (vxlan_get_sk_family(vs) == AF_INET) {
1252
		saddr.sin.sin_addr.s_addr = ip_hdr(skb)->saddr;
1253 1254 1255
		saddr.sa.sa_family = AF_INET;
#if IS_ENABLED(CONFIG_IPV6)
	} else {
1256
		saddr.sin6.sin6_addr = ipv6_hdr(skb)->saddr;
1257 1258 1259 1260
		saddr.sa.sa_family = AF_INET6;
#endif
	}

1261 1262 1263 1264 1265 1266 1267
	if ((vxlan->flags & VXLAN_F_LEARN) &&
	    vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source))
		return false;

	return true;
}

1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291
static bool vxlan_ecn_decapsulate(struct vxlan_sock *vs, void *oiph,
				  struct sk_buff *skb)
{
	int err = 0;

	if (vxlan_get_sk_family(vs) == AF_INET)
		err = IP_ECN_decapsulate(oiph, skb);
#if IS_ENABLED(CONFIG_IPV6)
	else
		err = IP6_ECN_decapsulate(oiph, skb);
#endif

	if (unlikely(err) && log_ecn_error) {
		if (vxlan_get_sk_family(vs) == AF_INET)
			net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
					     &((struct iphdr *)oiph)->saddr,
					     ((struct iphdr *)oiph)->tos);
		else
			net_info_ratelimited("non-ECT from %pI6\n",
					     &((struct ipv6hdr *)oiph)->saddr);
	}
	return err <= 1;
}

S
stephen hemminger 已提交
1292
/* Callback from net/ipv4/udp.c to receive packets */
1293
static int vxlan_rcv(struct sock *sk, struct sk_buff *skb)
S
stephen hemminger 已提交
1294
{
1295
	struct pcpu_sw_netstats *stats;
1296
	struct vxlan_dev *vxlan;
P
Pravin B Shelar 已提交
1297
	struct vxlan_sock *vs;
1298
	struct vxlanhdr unparsed;
T
Thomas Graf 已提交
1299 1300
	struct vxlan_metadata _md;
	struct vxlan_metadata *md = &_md;
J
Jiri Benc 已提交
1301
	__be16 protocol = htons(ETH_P_TEB);
J
Jiri Benc 已提交
1302
	bool raw_proto = false;
1303
	void *oiph;
S
stephen hemminger 已提交
1304

J
Jiri Benc 已提交
1305
	/* Need UDP and VXLAN header to be present */
1306
	if (!pskb_may_pull(skb, VXLAN_HLEN))
1307
		goto drop;
S
stephen hemminger 已提交
1308

1309
	unparsed = *vxlan_hdr(skb);
J
Jiri Benc 已提交
1310 1311 1312 1313 1314 1315
	/* VNI flag always required to be set */
	if (!(unparsed.vx_flags & VXLAN_HF_VNI)) {
		netdev_dbg(skb->dev, "invalid vxlan flags=%#x vni=%#x\n",
			   ntohl(vxlan_hdr(skb)->vx_flags),
			   ntohl(vxlan_hdr(skb)->vx_vni));
		/* Return non vxlan pkt */
1316
		goto drop;
S
stephen hemminger 已提交
1317
	}
J
Jiri Benc 已提交
1318 1319
	unparsed.vx_flags &= ~VXLAN_HF_VNI;
	unparsed.vx_vni &= ~VXLAN_VNI_MASK;
S
stephen hemminger 已提交
1320

1321
	vs = rcu_dereference_sk_user_data(sk);
P
Pravin B Shelar 已提交
1322
	if (!vs)
S
stephen hemminger 已提交
1323 1324
		goto drop;

1325 1326 1327 1328
	vxlan = vxlan_vs_find_vni(vs, vxlan_vni(vxlan_hdr(skb)->vx_vni));
	if (!vxlan)
		goto drop;

J
Jiri Benc 已提交
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
	/* For backwards compatibility, only allow reserved fields to be
	 * used by VXLAN extensions if explicitly requested.
	 */
	if (vs->flags & VXLAN_F_GPE) {
		if (!vxlan_parse_gpe_hdr(&unparsed, &protocol, skb, vs->flags))
			goto drop;
		raw_proto = true;
	}

	if (__iptunnel_pull_header(skb, VXLAN_HLEN, protocol, raw_proto,
				   !net_eq(vxlan->net, dev_net(vxlan->dev))))
			goto drop;
1341

T
Thomas Graf 已提交
1342
	if (vxlan_collect_metadata(vs)) {
J
Jiri Benc 已提交
1343
		__be32 vni = vxlan_vni(vxlan_hdr(skb)->vx_vni);
1344
		struct metadata_dst *tun_dst;
J
Jiri Benc 已提交
1345

1346
		tun_dst = udp_tun_rx_dst(skb, vxlan_get_sk_family(vs), TUNNEL_KEY,
J
Jiri Benc 已提交
1347
					 vxlan_vni_to_tun_id(vni), sizeof(*md));
1348

T
Thomas Graf 已提交
1349 1350 1351
		if (!tun_dst)
			goto drop;

1352
		md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
1353 1354

		skb_dst_set(skb, (struct dst_entry *)tun_dst);
T
Thomas Graf 已提交
1355 1356 1357 1358
	} else {
		memset(md, 0, sizeof(*md));
	}

1359 1360 1361 1362
	if (vs->flags & VXLAN_F_REMCSUM_RX)
		if (!vxlan_remcsum(&unparsed, skb, vs->flags))
			goto drop;
	if (vs->flags & VXLAN_F_GBP)
1363
		vxlan_parse_gbp_hdr(&unparsed, skb, vs->flags, md);
J
Jiri Benc 已提交
1364 1365 1366
	/* Note that GBP and GPE can never be active together. This is
	 * ensured in vxlan_dev_configure.
	 */
T
Thomas Graf 已提交
1367

1368
	if (unparsed.vx_flags || unparsed.vx_vni) {
1369 1370 1371 1372
		/* If there are any unprocessed flags remaining treat
		 * this as a malformed packet. This behavior diverges from
		 * VXLAN RFC (RFC7348) which stipulates that bits in reserved
		 * in reserved fields are to be ignored. The approach here
1373
		 * maintains compatibility with previous stack code, and also
1374 1375 1376
		 * is more robust and provides a little more security in
		 * adding extensions to VXLAN.
		 */
J
Jiri Benc 已提交
1377
		goto drop;
1378 1379
	}

J
Jiri Benc 已提交
1380 1381 1382 1383
	if (!raw_proto) {
		if (!vxlan_set_mac(vxlan, vs, skb))
			goto drop;
	} else {
1384
		skb_reset_mac_header(skb);
J
Jiri Benc 已提交
1385 1386 1387
		skb->dev = vxlan->dev;
		skb->pkt_type = PACKET_HOST;
	}
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404

	oiph = skb_network_header(skb);
	skb_reset_network_header(skb);

	if (!vxlan_ecn_decapsulate(vs, oiph, skb)) {
		++vxlan->dev->stats.rx_frame_errors;
		++vxlan->dev->stats.rx_errors;
		goto drop;
	}

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

	gro_cells_receive(&vxlan->gro_cells, skb);
P
Pravin B Shelar 已提交
1405 1406 1407
	return 0;

drop:
J
Jiri Benc 已提交
1408 1409 1410
	/* Consume bad packet */
	kfree_skb(skb);
	return 0;
P
Pravin B Shelar 已提交
1411 1412
}

D
David Stevens 已提交
1413 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 1460
static int arp_reduce(struct net_device *dev, struct sk_buff *skb)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct arphdr *parp;
	u8 *arpptr, *sha;
	__be32 sip, tip;
	struct neighbour *n;

	if (dev->flags & IFF_NOARP)
		goto out;

	if (!pskb_may_pull(skb, arp_hdr_len(dev))) {
		dev->stats.tx_dropped++;
		goto out;
	}
	parp = arp_hdr(skb);

	if ((parp->ar_hrd != htons(ARPHRD_ETHER) &&
	     parp->ar_hrd != htons(ARPHRD_IEEE802)) ||
	    parp->ar_pro != htons(ETH_P_IP) ||
	    parp->ar_op != htons(ARPOP_REQUEST) ||
	    parp->ar_hln != dev->addr_len ||
	    parp->ar_pln != 4)
		goto out;
	arpptr = (u8 *)parp + sizeof(struct arphdr);
	sha = arpptr;
	arpptr += dev->addr_len;	/* sha */
	memcpy(&sip, arpptr, sizeof(sip));
	arpptr += sizeof(sip);
	arpptr += dev->addr_len;	/* tha */
	memcpy(&tip, arpptr, sizeof(tip));

	if (ipv4_is_loopback(tip) ||
	    ipv4_is_multicast(tip))
		goto out;

	n = neigh_lookup(&arp_tbl, &tip, dev);

	if (n) {
		struct vxlan_fdb *f;
		struct sk_buff	*reply;

		if (!(n->nud_state & NUD_CONNECTED)) {
			neigh_release(n);
			goto out;
		}

		f = vxlan_find_mac(vxlan, n->ha);
C
Cong Wang 已提交
1461
		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
D
David Stevens 已提交
1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
			/* bridge-local neighbor */
			neigh_release(n);
			goto out;
		}

		reply = arp_create(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
				n->ha, sha);

		neigh_release(n);

1472 1473 1474
		if (reply == NULL)
			goto out;

D
David Stevens 已提交
1475 1476 1477 1478 1479 1480 1481
		skb_reset_mac_header(reply);
		__skb_pull(reply, skb_network_offset(reply));
		reply->ip_summed = CHECKSUM_UNNECESSARY;
		reply->pkt_type = PACKET_HOST;

		if (netif_rx_ni(reply) == NET_RX_DROP)
			dev->stats.rx_dropped++;
C
Cong Wang 已提交
1482 1483 1484
	} else if (vxlan->flags & VXLAN_F_L3MISS) {
		union vxlan_addr ipa = {
			.sin.sin_addr.s_addr = tip,
1485
			.sin.sin_family = AF_INET,
C
Cong Wang 已提交
1486 1487 1488 1489
		};

		vxlan_ip_miss(dev, &ipa);
	}
D
David Stevens 已提交
1490 1491 1492 1493 1494
out:
	consume_skb(skb);
	return NETDEV_TX_OK;
}

C
Cong Wang 已提交
1495
#if IS_ENABLED(CONFIG_IPV6)
1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
static struct sk_buff *vxlan_na_create(struct sk_buff *request,
	struct neighbour *n, bool isrouter)
{
	struct net_device *dev = request->dev;
	struct sk_buff *reply;
	struct nd_msg *ns, *na;
	struct ipv6hdr *pip6;
	u8 *daddr;
	int na_olen = 8; /* opt hdr + ETH_ALEN for target */
	int ns_olen;
	int i, len;

	if (dev == NULL)
		return NULL;

	len = LL_RESERVED_SPACE(dev) + sizeof(struct ipv6hdr) +
		sizeof(*na) + na_olen + dev->needed_tailroom;
	reply = alloc_skb(len, GFP_ATOMIC);
	if (reply == NULL)
		return NULL;

	reply->protocol = htons(ETH_P_IPV6);
	reply->dev = dev;
	skb_reserve(reply, LL_RESERVED_SPACE(request->dev));
	skb_push(reply, sizeof(struct ethhdr));
1521
	skb_reset_mac_header(reply);
1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540

	ns = (struct nd_msg *)skb_transport_header(request);

	daddr = eth_hdr(request)->h_source;
	ns_olen = request->len - skb_transport_offset(request) - sizeof(*ns);
	for (i = 0; i < ns_olen-1; i += (ns->opt[i+1]<<3)) {
		if (ns->opt[i] == ND_OPT_SOURCE_LL_ADDR) {
			daddr = ns->opt + i + sizeof(struct nd_opt_hdr);
			break;
		}
	}

	/* Ethernet header */
	ether_addr_copy(eth_hdr(reply)->h_dest, daddr);
	ether_addr_copy(eth_hdr(reply)->h_source, n->ha);
	eth_hdr(reply)->h_proto = htons(ETH_P_IPV6);
	reply->protocol = htons(ETH_P_IPV6);

	skb_pull(reply, sizeof(struct ethhdr));
1541
	skb_reset_network_header(reply);
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
	skb_put(reply, sizeof(struct ipv6hdr));

	/* IPv6 header */

	pip6 = ipv6_hdr(reply);
	memset(pip6, 0, sizeof(struct ipv6hdr));
	pip6->version = 6;
	pip6->priority = ipv6_hdr(request)->priority;
	pip6->nexthdr = IPPROTO_ICMPV6;
	pip6->hop_limit = 255;
	pip6->daddr = ipv6_hdr(request)->saddr;
	pip6->saddr = *(struct in6_addr *)n->primary_key;

	skb_pull(reply, sizeof(struct ipv6hdr));
1556
	skb_reset_transport_header(reply);
1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583

	na = (struct nd_msg *)skb_put(reply, sizeof(*na) + na_olen);

	/* Neighbor Advertisement */
	memset(na, 0, sizeof(*na)+na_olen);
	na->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;
	na->icmph.icmp6_router = isrouter;
	na->icmph.icmp6_override = 1;
	na->icmph.icmp6_solicited = 1;
	na->target = ns->target;
	ether_addr_copy(&na->opt[2], n->ha);
	na->opt[0] = ND_OPT_TARGET_LL_ADDR;
	na->opt[1] = na_olen >> 3;

	na->icmph.icmp6_cksum = csum_ipv6_magic(&pip6->saddr,
		&pip6->daddr, sizeof(*na)+na_olen, IPPROTO_ICMPV6,
		csum_partial(na, sizeof(*na)+na_olen, 0));

	pip6->payload_len = htons(sizeof(*na)+na_olen);

	skb_push(reply, sizeof(struct ipv6hdr));

	reply->ip_summed = CHECKSUM_UNNECESSARY;

	return reply;
}

C
Cong Wang 已提交
1584 1585 1586
static int neigh_reduce(struct net_device *dev, struct sk_buff *skb)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
1587
	struct nd_msg *msg;
C
Cong Wang 已提交
1588 1589
	const struct ipv6hdr *iphdr;
	const struct in6_addr *saddr, *daddr;
1590 1591
	struct neighbour *n;
	struct inet6_dev *in6_dev;
C
Cong Wang 已提交
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605

	in6_dev = __in6_dev_get(dev);
	if (!in6_dev)
		goto out;

	iphdr = ipv6_hdr(skb);
	saddr = &iphdr->saddr;
	daddr = &iphdr->daddr;

	msg = (struct nd_msg *)skb_transport_header(skb);
	if (msg->icmph.icmp6_code != 0 ||
	    msg->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION)
		goto out;

1606 1607 1608 1609 1610
	if (ipv6_addr_loopback(daddr) ||
	    ipv6_addr_is_multicast(&msg->target))
		goto out;

	n = neigh_lookup(ipv6_stub->nd_tbl, &msg->target, dev);
C
Cong Wang 已提交
1611 1612 1613

	if (n) {
		struct vxlan_fdb *f;
1614
		struct sk_buff *reply;
C
Cong Wang 已提交
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627

		if (!(n->nud_state & NUD_CONNECTED)) {
			neigh_release(n);
			goto out;
		}

		f = vxlan_find_mac(vxlan, n->ha);
		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
			/* bridge-local neighbor */
			neigh_release(n);
			goto out;
		}

1628 1629 1630
		reply = vxlan_na_create(skb, n,
					!!(f ? f->flags & NTF_ROUTER : 0));

C
Cong Wang 已提交
1631
		neigh_release(n);
1632 1633 1634 1635 1636 1637 1638

		if (reply == NULL)
			goto out;

		if (netif_rx_ni(reply) == NET_RX_DROP)
			dev->stats.rx_dropped++;

C
Cong Wang 已提交
1639
	} else if (vxlan->flags & VXLAN_F_L3MISS) {
1640 1641
		union vxlan_addr ipa = {
			.sin6.sin6_addr = msg->target,
1642
			.sin6.sin6_family = AF_INET6,
1643 1644
		};

C
Cong Wang 已提交
1645 1646 1647 1648 1649 1650 1651 1652 1653
		vxlan_ip_miss(dev, &ipa);
	}

out:
	consume_skb(skb);
	return NETDEV_TX_OK;
}
#endif

D
David Stevens 已提交
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct neighbour *n;

	if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))
		return false;

	n = NULL;
	switch (ntohs(eth_hdr(skb)->h_proto)) {
	case ETH_P_IP:
1665 1666 1667
	{
		struct iphdr *pip;

D
David Stevens 已提交
1668 1669 1670 1671
		if (!pskb_may_pull(skb, sizeof(struct iphdr)))
			return false;
		pip = ip_hdr(skb);
		n = neigh_lookup(&arp_tbl, &pip->daddr, dev);
C
Cong Wang 已提交
1672 1673 1674
		if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
			union vxlan_addr ipa = {
				.sin.sin_addr.s_addr = pip->daddr,
1675
				.sin.sin_family = AF_INET,
C
Cong Wang 已提交
1676 1677 1678 1679 1680 1681
			};

			vxlan_ip_miss(dev, &ipa);
			return false;
		}

D
David Stevens 已提交
1682
		break;
1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
	}
#if IS_ENABLED(CONFIG_IPV6)
	case ETH_P_IPV6:
	{
		struct ipv6hdr *pip6;

		if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
			return false;
		pip6 = ipv6_hdr(skb);
		n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev);
		if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
			union vxlan_addr ipa = {
				.sin6.sin6_addr = pip6->daddr,
1696
				.sin6.sin6_family = AF_INET6,
1697 1698 1699 1700 1701 1702 1703 1704 1705
			};

			vxlan_ip_miss(dev, &ipa);
			return false;
		}

		break;
	}
#endif
D
David Stevens 已提交
1706 1707 1708 1709 1710 1711 1712
	default:
		return false;
	}

	if (n) {
		bool diff;

1713
		diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);
D
David Stevens 已提交
1714 1715 1716 1717 1718 1719 1720
		if (diff) {
			memcpy(eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest,
				dev->addr_len);
			memcpy(eth_hdr(skb)->h_dest, n->ha, dev->addr_len);
		}
		neigh_release(n);
		return diff;
C
Cong Wang 已提交
1721 1722
	}

D
David Stevens 已提交
1723 1724 1725
	return false;
}

1726
static void vxlan_build_gbp_hdr(struct vxlanhdr *vxh, u32 vxflags,
T
Thomas Graf 已提交
1727 1728 1729 1730
				struct vxlan_metadata *md)
{
	struct vxlanhdr_gbp *gbp;

1731 1732 1733
	if (!md->gbp)
		return;

T
Thomas Graf 已提交
1734
	gbp = (struct vxlanhdr_gbp *)vxh;
1735
	vxh->vx_flags |= VXLAN_HF_GBP;
T
Thomas Graf 已提交
1736 1737 1738 1739 1740 1741 1742 1743 1744 1745

	if (md->gbp & VXLAN_GBP_DONT_LEARN)
		gbp->dont_learn = 1;

	if (md->gbp & VXLAN_GBP_POLICY_APPLIED)
		gbp->policy_applied = 1;

	gbp->policy_id = htons(md->gbp & VXLAN_GBP_ID_MASK);
}

J
Jiri Benc 已提交
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766
static int vxlan_build_gpe_hdr(struct vxlanhdr *vxh, u32 vxflags,
			       __be16 protocol)
{
	struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)vxh;

	gpe->np_applied = 1;

	switch (protocol) {
	case htons(ETH_P_IP):
		gpe->next_protocol = VXLAN_GPE_NP_IPV4;
		return 0;
	case htons(ETH_P_IPV6):
		gpe->next_protocol = VXLAN_GPE_NP_IPV6;
		return 0;
	case htons(ETH_P_TEB):
		gpe->next_protocol = VXLAN_GPE_NP_ETHERNET;
		return 0;
	}
	return -EPFNOSUPPORT;
}

1767 1768 1769
static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,
			   int iphdr_len, __be32 vni,
			   struct vxlan_metadata *md, u32 vxflags,
1770
			   bool udp_sum)
C
Cong Wang 已提交
1771 1772 1773 1774
{
	struct vxlanhdr *vxh;
	int min_headroom;
	int err;
T
Tom Herbert 已提交
1775
	int type = udp_sum ? SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
J
Jiri Benc 已提交
1776
	__be16 inner_protocol = htons(ETH_P_TEB);
T
Tom Herbert 已提交
1777

1778
	if ((vxflags & VXLAN_F_REMCSUM_TX) &&
T
Tom Herbert 已提交
1779 1780 1781 1782 1783 1784
	    skb->ip_summed == CHECKSUM_PARTIAL) {
		int csum_start = skb_checksum_start_offset(skb);

		if (csum_start <= VXLAN_MAX_REMCSUM_START &&
		    !(csum_start & VXLAN_RCO_SHIFT_MASK) &&
		    (skb->csum_offset == offsetof(struct udphdr, check) ||
1785
		     skb->csum_offset == offsetof(struct tcphdr, check)))
T
Tom Herbert 已提交
1786 1787
			type |= SKB_GSO_TUNNEL_REMCSUM;
	}
C
Cong Wang 已提交
1788 1789

	min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len
1790
			+ VXLAN_HLEN + iphdr_len
1791
			+ (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0);
1792 1793 1794

	/* Need space for new headers (invalidates iph ptr) */
	err = skb_cow_head(skb, min_headroom);
J
Jiri Benc 已提交
1795 1796
	if (unlikely(err))
		goto out_free;
1797

1798 1799 1800
	skb = vlan_hwaccel_push_inside(skb);
	if (WARN_ON(!skb))
		return -ENOMEM;
1801

1802 1803 1804
	err = iptunnel_handle_offloads(skb, type);
	if (err)
		goto out_free;
1805

1806
	vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
1807 1808
	vxh->vx_flags = VXLAN_HF_VNI;
	vxh->vx_vni = vxlan_vni_field(vni);
1809

T
Tom Herbert 已提交
1810
	if (type & SKB_GSO_TUNNEL_REMCSUM) {
1811
		unsigned int start;
T
Tom Herbert 已提交
1812

1813 1814 1815
		start = skb_checksum_start_offset(skb) - sizeof(struct vxlanhdr);
		vxh->vx_vni |= vxlan_compute_rco(start, skb->csum_offset);
		vxh->vx_flags |= VXLAN_HF_RCO;
T
Tom Herbert 已提交
1816 1817 1818 1819 1820 1821 1822

		if (!skb_is_gso(skb)) {
			skb->ip_summed = CHECKSUM_NONE;
			skb->encapsulation = 0;
		}
	}

1823 1824
	if (vxflags & VXLAN_F_GBP)
		vxlan_build_gbp_hdr(vxh, vxflags, md);
J
Jiri Benc 已提交
1825 1826 1827 1828 1829 1830
	if (vxflags & VXLAN_F_GPE) {
		err = vxlan_build_gpe_hdr(vxh, vxflags, skb->protocol);
		if (err < 0)
			goto out_free;
		inner_protocol = skb->protocol;
	}
T
Thomas Graf 已提交
1831

J
Jiri Benc 已提交
1832
	skb_set_inner_protocol(skb, inner_protocol);
1833
	return 0;
J
Jiri Benc 已提交
1834 1835 1836 1837

out_free:
	kfree_skb(skb);
	return err;
1838 1839
}

1840 1841
static struct rtable *vxlan_get_route(struct vxlan_dev *vxlan,
				      struct sk_buff *skb, int oif, u8 tos,
1842 1843
				      __be32 daddr, __be32 *saddr,
				      struct dst_cache *dst_cache,
1844
				      const struct ip_tunnel_info *info)
1845
{
1846
	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
1847 1848 1849
	struct rtable *rt = NULL;
	struct flowi4 fl4;

1850 1851 1852
	if (tos && !info)
		use_cache = false;
	if (use_cache) {
1853 1854 1855 1856 1857
		rt = dst_cache_get_ip4(dst_cache, saddr);
		if (rt)
			return rt;
	}

1858 1859 1860 1861 1862 1863 1864 1865 1866
	memset(&fl4, 0, sizeof(fl4));
	fl4.flowi4_oif = oif;
	fl4.flowi4_tos = RT_TOS(tos);
	fl4.flowi4_mark = skb->mark;
	fl4.flowi4_proto = IPPROTO_UDP;
	fl4.daddr = daddr;
	fl4.saddr = vxlan->cfg.saddr.sin.sin_addr.s_addr;

	rt = ip_route_output_key(vxlan->net, &fl4);
1867
	if (!IS_ERR(rt)) {
1868
		*saddr = fl4.saddr;
1869 1870 1871
		if (use_cache)
			dst_cache_set_ip4(dst_cache, &rt->dst, fl4.saddr);
	}
1872 1873 1874
	return rt;
}

1875 1876
#if IS_ENABLED(CONFIG_IPV6)
static struct dst_entry *vxlan6_get_route(struct vxlan_dev *vxlan,
1877
					  struct sk_buff *skb, int oif, u8 tos,
1878
					  __be32 label,
1879
					  const struct in6_addr *daddr,
1880
					  struct in6_addr *saddr,
1881 1882
					  struct dst_cache *dst_cache,
					  const struct ip_tunnel_info *info)
1883
{
1884
	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
1885 1886 1887 1888
	struct dst_entry *ndst;
	struct flowi6 fl6;
	int err;

1889 1890
	if (tos && !info)
		use_cache = false;
1891
	if (use_cache) {
1892 1893 1894 1895 1896
		ndst = dst_cache_get_ip6(dst_cache, saddr);
		if (ndst)
			return ndst;
	}

1897 1898 1899 1900
	memset(&fl6, 0, sizeof(fl6));
	fl6.flowi6_oif = oif;
	fl6.daddr = *daddr;
	fl6.saddr = vxlan->cfg.saddr.sin6.sin6_addr;
1901
	fl6.flowlabel = ip6_make_flowinfo(RT_TOS(tos), label);
1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
	fl6.flowi6_mark = skb->mark;
	fl6.flowi6_proto = IPPROTO_UDP;

	err = ipv6_stub->ipv6_dst_lookup(vxlan->net,
					 vxlan->vn6_sock->sock->sk,
					 &ndst, &fl6);
	if (err < 0)
		return ERR_PTR(err);

	*saddr = fl6.saddr;
1912
	if (use_cache)
1913
		dst_cache_set_ip6(dst_cache, ndst, saddr);
1914 1915 1916 1917
	return ndst;
}
#endif

1918 1919 1920 1921
/* Bypass encapsulation if the destination is local */
static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan,
			       struct vxlan_dev *dst_vxlan)
{
1922
	struct pcpu_sw_netstats *tx_stats, *rx_stats;
C
Cong Wang 已提交
1923 1924
	union vxlan_addr loopback;
	union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;
1925 1926
	struct net_device *dev = skb->dev;
	int len = skb->len;
1927

1928 1929
	tx_stats = this_cpu_ptr(src_vxlan->dev->tstats);
	rx_stats = this_cpu_ptr(dst_vxlan->dev->tstats);
1930 1931 1932 1933 1934
	skb->pkt_type = PACKET_HOST;
	skb->encapsulation = 0;
	skb->dev = dst_vxlan->dev;
	__skb_pull(skb, skb_network_offset(skb));

C
Cong Wang 已提交
1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
	if (remote_ip->sa.sa_family == AF_INET) {
		loopback.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
		loopback.sa.sa_family =  AF_INET;
#if IS_ENABLED(CONFIG_IPV6)
	} else {
		loopback.sin6.sin6_addr = in6addr_loopback;
		loopback.sa.sa_family =  AF_INET6;
#endif
	}

1945
	if (dst_vxlan->flags & VXLAN_F_LEARN)
C
Cong Wang 已提交
1946
		vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source);
1947 1948 1949

	u64_stats_update_begin(&tx_stats->syncp);
	tx_stats->tx_packets++;
1950
	tx_stats->tx_bytes += len;
1951 1952 1953 1954 1955
	u64_stats_update_end(&tx_stats->syncp);

	if (netif_rx(skb) == NET_RX_SUCCESS) {
		u64_stats_update_begin(&rx_stats->syncp);
		rx_stats->rx_packets++;
1956
		rx_stats->rx_bytes += len;
1957 1958
		u64_stats_update_end(&rx_stats->syncp);
	} else {
1959
		dev->stats.rx_dropped++;
1960 1961 1962
	}
}

1963 1964
static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
			   struct vxlan_rdst *rdst, bool did_rsc)
S
stephen hemminger 已提交
1965
{
1966
	struct dst_cache *dst_cache;
1967
	struct ip_tunnel_info *info;
S
stephen hemminger 已提交
1968
	struct vxlan_dev *vxlan = netdev_priv(dev);
1969
	struct sock *sk;
C
Cong Wang 已提交
1970
	struct rtable *rt = NULL;
S
stephen hemminger 已提交
1971
	const struct iphdr *old_iph;
C
Cong Wang 已提交
1972
	union vxlan_addr *dst;
T
Thomas Graf 已提交
1973 1974 1975
	union vxlan_addr remote_ip;
	struct vxlan_metadata _md;
	struct vxlan_metadata *md = &_md;
C
Cong Wang 已提交
1976
	__be16 src_port = 0, dst_port;
1977
	__be32 vni, label;
S
stephen hemminger 已提交
1978 1979
	__be16 df = 0;
	__u8 tos, ttl;
1980
	int err;
T
Thomas Graf 已提交
1981
	u32 flags = vxlan->flags;
1982
	bool udp_sum = false;
1983
	bool xnet = !net_eq(vxlan->net, dev_net(vxlan->dev));
S
stephen hemminger 已提交
1984

1985
	info = skb_tunnel_info(skb);
1986

T
Thomas Graf 已提交
1987
	if (rdst) {
1988
		dst_port = rdst->remote_port ? rdst->remote_port : vxlan->cfg.dst_port;
T
Thomas Graf 已提交
1989 1990
		vni = rdst->remote_vni;
		dst = &rdst->remote_ip;
1991
		dst_cache = &rdst->dst_cache;
T
Thomas Graf 已提交
1992 1993 1994 1995 1996 1997
	} else {
		if (!info) {
			WARN_ONCE(1, "%s: Missing encapsulation instructions\n",
				  dev->name);
			goto drop;
		}
1998
		dst_port = info->key.tp_dst ? : vxlan->cfg.dst_port;
1999
		vni = vxlan_tun_id_to_vni(info->key.tun_id);
2000 2001
		remote_ip.sa.sa_family = ip_tunnel_info_af(info);
		if (remote_ip.sa.sa_family == AF_INET)
2002 2003 2004
			remote_ip.sin.sin_addr.s_addr = info->key.u.ipv4.dst;
		else
			remote_ip.sin6.sin6_addr = info->key.u.ipv6.dst;
T
Thomas Graf 已提交
2005
		dst = &remote_ip;
2006
		dst_cache = &info->dst_cache;
T
Thomas Graf 已提交
2007
	}
D
David Stevens 已提交
2008

C
Cong Wang 已提交
2009
	if (vxlan_addr_any(dst)) {
D
David Stevens 已提交
2010 2011
		if (did_rsc) {
			/* short-circuited back to local bridge */
2012
			vxlan_encap_bypass(skb, vxlan, vxlan);
2013
			return;
D
David Stevens 已提交
2014
		}
2015
		goto drop;
D
David Stevens 已提交
2016
	}
2017

S
stephen hemminger 已提交
2018 2019
	old_iph = ip_hdr(skb);

2020
	ttl = vxlan->cfg.ttl;
C
Cong Wang 已提交
2021
	if (!ttl && vxlan_addr_multicast(dst))
S
stephen hemminger 已提交
2022 2023
		ttl = 1;

2024
	tos = vxlan->cfg.tos;
S
stephen hemminger 已提交
2025
	if (tos == 1)
2026
		tos = ip_tunnel_get_dsfield(old_iph, skb);
S
stephen hemminger 已提交
2027

2028
	label = vxlan->cfg.label;
2029 2030
	src_port = udp_flow_src_port(dev_net(dev), skb, vxlan->cfg.port_min,
				     vxlan->cfg.port_max, true);
S
stephen hemminger 已提交
2031

2032 2033 2034
	if (info) {
		ttl = info->key.ttl;
		tos = info->key.tos;
2035
		label = info->key.label;
2036
		udp_sum = !!(info->key.tun_flags & TUNNEL_CSUM);
2037 2038

		if (info->options_len)
2039
			md = ip_tunnel_info_opts(info);
2040 2041 2042 2043
	} else {
		md->gbp = skb->mark;
	}

C
Cong Wang 已提交
2044
	if (dst->sa.sa_family == AF_INET) {
2045 2046
		__be32 saddr;

2047 2048 2049 2050
		if (!vxlan->vn4_sock)
			goto drop;
		sk = vxlan->vn4_sock->sock->sk;

2051 2052
		rt = vxlan_get_route(vxlan, skb,
				     rdst ? rdst->remote_ifindex : 0, tos,
2053
				     dst->sin.sin_addr.s_addr, &saddr,
2054
				     dst_cache, info);
C
Cong Wang 已提交
2055 2056 2057 2058 2059 2060
		if (IS_ERR(rt)) {
			netdev_dbg(dev, "no route to %pI4\n",
				   &dst->sin.sin_addr.s_addr);
			dev->stats.tx_carrier_errors++;
			goto tx_error;
		}
S
stephen hemminger 已提交
2061

C
Cong Wang 已提交
2062 2063 2064 2065
		if (rt->dst.dev == dev) {
			netdev_dbg(dev, "circular route to %pI4\n",
				   &dst->sin.sin_addr.s_addr);
			dev->stats.collisions++;
2066
			goto rt_tx_error;
C
Cong Wang 已提交
2067 2068 2069 2070 2071 2072 2073 2074
		}

		/* Bypass encapsulation if the destination is local */
		if (rt->rt_flags & RTCF_LOCAL &&
		    !(rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
			struct vxlan_dev *dst_vxlan;

			ip_rt_put(rt);
2075
			dst_vxlan = vxlan_find_vni(vxlan->net, vni,
2076 2077
						   dst->sa.sa_family, dst_port,
						   vxlan->flags);
C
Cong Wang 已提交
2078 2079 2080 2081 2082 2083
			if (!dst_vxlan)
				goto tx_error;
			vxlan_encap_bypass(skb, vxlan, dst_vxlan);
			return;
		}

2084 2085 2086 2087 2088
		if (!info)
			udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM_TX);
		else if (info->key.tun_flags & TUNNEL_DONT_FRAGMENT)
			df = htons(IP_DF);

C
Cong Wang 已提交
2089 2090
		tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
		ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
2091
		err = vxlan_build_skb(skb, &rt->dst, sizeof(struct iphdr),
2092
				      vni, md, flags, udp_sum);
2093 2094 2095 2096 2097 2098
		if (err < 0)
			goto xmit_tx_error;

		udp_tunnel_xmit_skb(rt, sk, skb, saddr,
				    dst->sin.sin_addr.s_addr, tos, ttl, df,
				    src_port, dst_port, xnet, !udp_sum);
C
Cong Wang 已提交
2099 2100 2101
#if IS_ENABLED(CONFIG_IPV6)
	} else {
		struct dst_entry *ndst;
2102
		struct in6_addr saddr;
J
Jiri Benc 已提交
2103
		u32 rt6i_flags;
C
Cong Wang 已提交
2104

2105 2106 2107 2108
		if (!vxlan->vn6_sock)
			goto drop;
		sk = vxlan->vn6_sock->sock->sk;

2109
		ndst = vxlan6_get_route(vxlan, skb,
2110
					rdst ? rdst->remote_ifindex : 0, tos,
2111
					label, &dst->sin6.sin6_addr, &saddr,
2112
					dst_cache, info);
2113
		if (IS_ERR(ndst)) {
C
Cong Wang 已提交
2114 2115 2116
			netdev_dbg(dev, "no route to %pI6\n",
				   &dst->sin6.sin6_addr);
			dev->stats.tx_carrier_errors++;
2117
			goto tx_error;
C
Cong Wang 已提交
2118
		}
S
stephen hemminger 已提交
2119

C
Cong Wang 已提交
2120 2121 2122 2123 2124 2125 2126
		if (ndst->dev == dev) {
			netdev_dbg(dev, "circular route to %pI6\n",
				   &dst->sin6.sin6_addr);
			dst_release(ndst);
			dev->stats.collisions++;
			goto tx_error;
		}
2127

C
Cong Wang 已提交
2128
		/* Bypass encapsulation if the destination is local */
J
Jiri Benc 已提交
2129 2130 2131
		rt6i_flags = ((struct rt6_info *)ndst)->rt6i_flags;
		if (rt6i_flags & RTF_LOCAL &&
		    !(rt6i_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
C
Cong Wang 已提交
2132 2133 2134
			struct vxlan_dev *dst_vxlan;

			dst_release(ndst);
2135
			dst_vxlan = vxlan_find_vni(vxlan->net, vni,
2136 2137
						   dst->sa.sa_family, dst_port,
						   vxlan->flags);
C
Cong Wang 已提交
2138 2139 2140 2141 2142
			if (!dst_vxlan)
				goto tx_error;
			vxlan_encap_bypass(skb, vxlan, dst_vxlan);
			return;
		}
2143

2144 2145
		if (!info)
			udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM6_TX);
2146

2147
		tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
C
Cong Wang 已提交
2148
		ttl = ttl ? : ip6_dst_hoplimit(ndst);
2149 2150
		skb_scrub_packet(skb, xnet);
		err = vxlan_build_skb(skb, ndst, sizeof(struct ipv6hdr),
2151
				      vni, md, flags, udp_sum);
2152 2153 2154 2155 2156
		if (err < 0) {
			dst_release(ndst);
			return;
		}
		udp_tunnel6_xmit_skb(ndst, sk, skb, dev,
2157 2158
				     &saddr, &dst->sin6.sin6_addr, tos, ttl,
				     label, src_port, dst_port, !udp_sum);
C
Cong Wang 已提交
2159 2160
#endif
	}
2161

2162
	return;
S
stephen hemminger 已提交
2163 2164 2165 2166 2167

drop:
	dev->stats.tx_dropped++;
	goto tx_free;

2168 2169 2170
xmit_tx_error:
	/* skb is already freed. */
	skb = NULL;
2171 2172
rt_tx_error:
	ip_rt_put(rt);
S
stephen hemminger 已提交
2173 2174 2175 2176 2177 2178
tx_error:
	dev->stats.tx_errors++;
tx_free:
	dev_kfree_skb(skb);
}

2179 2180 2181 2182 2183 2184 2185 2186 2187
/* Transmit local packets over Vxlan
 *
 * Outer IP header inherits ECN and DF from inner header.
 * Outer UDP destination is the VXLAN assigned port.
 *           source port is based on hash of flow
 */
static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
2188
	const struct ip_tunnel_info *info;
2189 2190
	struct ethhdr *eth;
	bool did_rsc = false;
2191
	struct vxlan_rdst *rdst, *fdst = NULL;
2192 2193
	struct vxlan_fdb *f;

2194
	info = skb_tunnel_info(skb);
2195

2196 2197
	skb_reset_mac_header(skb);

2198 2199 2200 2201 2202 2203 2204 2205 2206 2207
	if (vxlan->flags & VXLAN_F_COLLECT_METADATA) {
		if (info && info->mode & IP_TUNNEL_INFO_TX)
			vxlan_xmit_one(skb, dev, NULL, false);
		else
			kfree_skb(skb);
		return NETDEV_TX_OK;
	}

	if (vxlan->flags & VXLAN_F_PROXY) {
		eth = eth_hdr(skb);
C
Cong Wang 已提交
2208 2209 2210 2211
		if (ntohs(eth->h_proto) == ETH_P_ARP)
			return arp_reduce(dev, skb);
#if IS_ENABLED(CONFIG_IPV6)
		else if (ntohs(eth->h_proto) == ETH_P_IPV6 &&
2212 2213
			 pskb_may_pull(skb, sizeof(struct ipv6hdr)
				       + sizeof(struct nd_msg)) &&
C
Cong Wang 已提交
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223
			 ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {
				struct nd_msg *msg;

				msg = (struct nd_msg *)skb_transport_header(skb);
				if (msg->icmph.icmp6_code == 0 &&
				    msg->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION)
					return neigh_reduce(dev, skb);
		}
#endif
	}
2224

2225
	eth = eth_hdr(skb);
2226
	f = vxlan_find_mac(vxlan, eth->h_dest);
2227 2228 2229
	did_rsc = false;

	if (f && (f->flags & NTF_ROUTER) && (vxlan->flags & VXLAN_F_RSC) &&
2230 2231
	    (ntohs(eth->h_proto) == ETH_P_IP ||
	     ntohs(eth->h_proto) == ETH_P_IPV6)) {
2232 2233 2234 2235 2236
		did_rsc = route_shortcircuit(dev, skb);
		if (did_rsc)
			f = vxlan_find_mac(vxlan, eth->h_dest);
	}

2237
	if (f == NULL) {
2238 2239 2240 2241 2242 2243 2244
		f = vxlan_find_mac(vxlan, all_zeros_mac);
		if (f == NULL) {
			if ((vxlan->flags & VXLAN_F_L2MISS) &&
			    !is_multicast_ether_addr(eth->h_dest))
				vxlan_fdb_miss(vxlan, eth->h_dest);

			dev->stats.tx_dropped++;
2245
			kfree_skb(skb);
2246 2247 2248
			return NETDEV_TX_OK;
		}
	}
2249

2250 2251
	list_for_each_entry_rcu(rdst, &f->remotes, list) {
		struct sk_buff *skb1;
2252

2253 2254 2255 2256
		if (!fdst) {
			fdst = rdst;
			continue;
		}
2257 2258 2259
		skb1 = skb_clone(skb, GFP_ATOMIC);
		if (skb1)
			vxlan_xmit_one(skb1, dev, rdst, did_rsc);
2260 2261
	}

2262 2263 2264 2265
	if (fdst)
		vxlan_xmit_one(skb, dev, fdst, did_rsc);
	else
		kfree_skb(skb);
2266
	return NETDEV_TX_OK;
2267 2268
}

S
stephen hemminger 已提交
2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
/* Walk the forwarding table and purge stale entries */
static void vxlan_cleanup(unsigned long arg)
{
	struct vxlan_dev *vxlan = (struct vxlan_dev *) arg;
	unsigned long next_timer = jiffies + FDB_AGE_INTERVAL;
	unsigned int h;

	if (!netif_running(vxlan->dev))
		return;

	for (h = 0; h < FDB_HASH_SIZE; ++h) {
		struct hlist_node *p, *n;
2281 2282

		spin_lock_bh(&vxlan->hash_lock);
S
stephen hemminger 已提交
2283 2284 2285 2286 2287
		hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
			struct vxlan_fdb *f
				= container_of(p, struct vxlan_fdb, hlist);
			unsigned long timeout;

2288
			if (f->state & NUD_PERMANENT)
S
stephen hemminger 已提交
2289 2290
				continue;

2291
			timeout = f->used + vxlan->cfg.age_interval * HZ;
S
stephen hemminger 已提交
2292 2293 2294 2295 2296 2297 2298 2299 2300
			if (time_before_eq(timeout, jiffies)) {
				netdev_dbg(vxlan->dev,
					   "garbage collect %pM\n",
					   f->eth_addr);
				f->state = NUD_STALE;
				vxlan_fdb_destroy(vxlan, f);
			} else if (time_before(timeout, next_timer))
				next_timer = timeout;
		}
2301
		spin_unlock_bh(&vxlan->hash_lock);
S
stephen hemminger 已提交
2302 2303 2304 2305 2306
	}

	mod_timer(&vxlan->age_timer, next_timer);
}

2307 2308
static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan)
{
2309
	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
2310
	__be32 vni = vxlan->default_dst.remote_vni;
2311

2312
	spin_lock(&vn->sock_lock);
2313
	hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));
2314
	spin_unlock(&vn->sock_lock);
2315 2316
}

S
stephen hemminger 已提交
2317 2318 2319
/* Setup stats when device is created */
static int vxlan_init(struct net_device *dev)
{
2320
	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
2321
	if (!dev->tstats)
S
stephen hemminger 已提交
2322 2323 2324 2325 2326
		return -ENOMEM;

	return 0;
}

2327
static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan)
2328 2329 2330 2331 2332 2333 2334 2335 2336 2337
{
	struct vxlan_fdb *f;

	spin_lock_bh(&vxlan->hash_lock);
	f = __vxlan_find_mac(vxlan, all_zeros_mac);
	if (f)
		vxlan_fdb_destroy(vxlan, f);
	spin_unlock_bh(&vxlan->hash_lock);
}

2338 2339 2340 2341
static void vxlan_uninit(struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);

2342
	vxlan_fdb_delete_default(vxlan);
2343

2344 2345 2346
	free_percpu(dev->tstats);
}

S
stephen hemminger 已提交
2347 2348 2349 2350
/* Start ageing timer and join group when device is brought up */
static int vxlan_open(struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
2351
	int ret;
2352

2353 2354 2355
	ret = vxlan_sock_add(vxlan);
	if (ret < 0)
		return ret;
S
stephen hemminger 已提交
2356

2357
	if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip)) {
2358
		ret = vxlan_igmp_join(vxlan);
2359 2360
		if (ret == -EADDRINUSE)
			ret = 0;
2361
		if (ret) {
2362
			vxlan_sock_release(vxlan);
2363 2364
			return ret;
		}
S
stephen hemminger 已提交
2365 2366
	}

2367
	if (vxlan->cfg.age_interval)
S
stephen hemminger 已提交
2368 2369
		mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);

2370
	return ret;
S
stephen hemminger 已提交
2371 2372 2373 2374 2375
}

/* Purge the forwarding table */
static void vxlan_flush(struct vxlan_dev *vxlan)
{
2376
	unsigned int h;
S
stephen hemminger 已提交
2377 2378 2379 2380 2381 2382 2383

	spin_lock_bh(&vxlan->hash_lock);
	for (h = 0; h < FDB_HASH_SIZE; ++h) {
		struct hlist_node *p, *n;
		hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
			struct vxlan_fdb *f
				= container_of(p, struct vxlan_fdb, hlist);
2384 2385 2386
			/* the all_zeros_mac entry is deleted at vxlan_uninit */
			if (!is_zero_ether_addr(f->eth_addr))
				vxlan_fdb_destroy(vxlan, f);
S
stephen hemminger 已提交
2387 2388 2389 2390 2391 2392 2393 2394 2395
		}
	}
	spin_unlock_bh(&vxlan->hash_lock);
}

/* Cleanup timer and forwarding table on shutdown */
static int vxlan_stop(struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
N
Nicolas Dichtel 已提交
2396
	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
2397
	int ret = 0;
S
stephen hemminger 已提交
2398

2399
	if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&
2400
	    !vxlan_group_used(vn, vxlan))
2401
		ret = vxlan_igmp_leave(vxlan);
S
stephen hemminger 已提交
2402 2403 2404 2405

	del_timer_sync(&vxlan->age_timer);

	vxlan_flush(vxlan);
2406
	vxlan_sock_release(vxlan);
S
stephen hemminger 已提交
2407

2408
	return ret;
S
stephen hemminger 已提交
2409 2410 2411 2412 2413 2414 2415
}

/* Stub, nothing needs to be done. */
static void vxlan_set_multicast_list(struct net_device *dev)
{
}

D
David Wragg 已提交
2416 2417 2418
static int __vxlan_change_mtu(struct net_device *dev,
			      struct net_device *lowerdev,
			      struct vxlan_rdst *dst, int new_mtu, bool strict)
2419
{
D
David Wragg 已提交
2420
	int max_mtu = IP_MAX_MTU;
2421

D
David Wragg 已提交
2422 2423
	if (lowerdev)
		max_mtu = lowerdev->mtu;
2424 2425

	if (dst->remote_ip.sa.sa_family == AF_INET6)
D
David Wragg 已提交
2426
		max_mtu -= VXLAN6_HEADROOM;
2427
	else
D
David Wragg 已提交
2428
		max_mtu -= VXLAN_HEADROOM;
2429

D
David Wragg 已提交
2430
	if (new_mtu < 68)
2431 2432
		return -EINVAL;

D
David Wragg 已提交
2433 2434 2435 2436 2437 2438 2439
	if (new_mtu > max_mtu) {
		if (strict)
			return -EINVAL;

		new_mtu = max_mtu;
	}

2440 2441 2442 2443
	dev->mtu = new_mtu;
	return 0;
}

D
David Wragg 已提交
2444 2445 2446 2447 2448 2449 2450 2451 2452
static int vxlan_change_mtu(struct net_device *dev, int new_mtu)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_rdst *dst = &vxlan->default_dst;
	struct net_device *lowerdev = __dev_get_by_index(vxlan->net,
							 dst->remote_ifindex);
	return __vxlan_change_mtu(dev, lowerdev, dst, new_mtu, true);
}

2453 2454 2455 2456 2457 2458 2459 2460 2461 2462
static int vxlan_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct ip_tunnel_info *info = skb_tunnel_info(skb);
	__be16 sport, dport;

	sport = udp_flow_src_port(dev_net(dev), skb, vxlan->cfg.port_min,
				  vxlan->cfg.port_max, true);
	dport = info->key.tp_dst ? : vxlan->cfg.dst_port;

2463
	if (ip_tunnel_info_af(info) == AF_INET) {
2464 2465
		struct rtable *rt;

2466 2467
		if (!vxlan->vn4_sock)
			return -EINVAL;
2468 2469
		rt = vxlan_get_route(vxlan, skb, 0, info->key.tos,
				     info->key.u.ipv4.dst,
2470
				     &info->key.u.ipv4.src, NULL, info);
2471 2472 2473
		if (IS_ERR(rt))
			return PTR_ERR(rt);
		ip_rt_put(rt);
2474 2475 2476 2477 2478 2479
	} else {
#if IS_ENABLED(CONFIG_IPV6)
		struct dst_entry *ndst;

		if (!vxlan->vn6_sock)
			return -EINVAL;
2480
		ndst = vxlan6_get_route(vxlan, skb, 0, info->key.tos,
2481
					info->key.label, &info->key.u.ipv6.dst,
2482
					&info->key.u.ipv6.src, NULL, info);
2483 2484 2485 2486 2487 2488 2489
		if (IS_ERR(ndst))
			return PTR_ERR(ndst);
		dst_release(ndst);
#else /* !CONFIG_IPV6 */
		return -EPFNOSUPPORT;
#endif
	}
2490 2491
	info->key.tp_src = sport;
	info->key.tp_dst = dport;
2492
	return 0;
2493 2494
}

2495
static const struct net_device_ops vxlan_netdev_ether_ops = {
S
stephen hemminger 已提交
2496
	.ndo_init		= vxlan_init,
2497
	.ndo_uninit		= vxlan_uninit,
S
stephen hemminger 已提交
2498 2499 2500
	.ndo_open		= vxlan_open,
	.ndo_stop		= vxlan_stop,
	.ndo_start_xmit		= vxlan_xmit,
2501
	.ndo_get_stats64	= ip_tunnel_get_stats64,
S
stephen hemminger 已提交
2502
	.ndo_set_rx_mode	= vxlan_set_multicast_list,
2503
	.ndo_change_mtu		= vxlan_change_mtu,
S
stephen hemminger 已提交
2504 2505 2506 2507 2508
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_set_mac_address	= eth_mac_addr,
	.ndo_fdb_add		= vxlan_fdb_add,
	.ndo_fdb_del		= vxlan_fdb_delete,
	.ndo_fdb_dump		= vxlan_fdb_dump,
2509
	.ndo_fill_metadata_dst	= vxlan_fill_metadata_dst,
S
stephen hemminger 已提交
2510 2511
};

J
Jiri Benc 已提交
2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522
static const struct net_device_ops vxlan_netdev_raw_ops = {
	.ndo_init		= vxlan_init,
	.ndo_uninit		= vxlan_uninit,
	.ndo_open		= vxlan_open,
	.ndo_stop		= vxlan_stop,
	.ndo_start_xmit		= vxlan_xmit,
	.ndo_get_stats64	= ip_tunnel_get_stats64,
	.ndo_change_mtu		= vxlan_change_mtu,
	.ndo_fill_metadata_dst	= vxlan_fill_metadata_dst,
};

S
stephen hemminger 已提交
2523 2524 2525 2526 2527
/* Info for udev, that this is a virtual tunnel endpoint */
static struct device_type vxlan_type = {
	.name = "vxlan",
};

2528
/* Calls the ndo_add_vxlan_port of the caller in order to
J
Joseph Gasparakis 已提交
2529 2530
 * supply the listening VXLAN udp ports. Callers are expected
 * to implement the ndo_add_vxlan_port.
2531
 */
2532
static void vxlan_push_rx_ports(struct net_device *dev)
2533 2534 2535 2536 2537
{
	struct vxlan_sock *vs;
	struct net *net = dev_net(dev);
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
	sa_family_t sa_family;
J
Joseph Gasparakis 已提交
2538 2539
	__be16 port;
	unsigned int i;
2540

2541 2542 2543
	if (!dev->netdev_ops->ndo_add_vxlan_port)
		return;

2544 2545
	spin_lock(&vn->sock_lock);
	for (i = 0; i < PORT_HASH_SIZE; ++i) {
J
Joseph Gasparakis 已提交
2546 2547
		hlist_for_each_entry_rcu(vs, &vn->sock_list[i], hlist) {
			port = inet_sk(vs->sock->sk)->inet_sport;
2548
			sa_family = vxlan_get_sk_family(vs);
2549 2550 2551 2552 2553 2554 2555
			dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,
							    port);
		}
	}
	spin_unlock(&vn->sock_lock);
}

S
stephen hemminger 已提交
2556 2557 2558 2559
/* Initialize the device structure. */
static void vxlan_setup(struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
2560
	unsigned int h;
S
stephen hemminger 已提交
2561

2562 2563 2564
	eth_hw_addr_random(dev);
	ether_setup(dev);

2565
	dev->destructor = free_netdev;
S
stephen hemminger 已提交
2566 2567 2568
	SET_NETDEV_DEVTYPE(dev, &vxlan_type);

	dev->features	|= NETIF_F_LLTX;
2569
	dev->features	|= NETIF_F_SG | NETIF_F_HW_CSUM;
2570
	dev->features   |= NETIF_F_RXCSUM;
2571
	dev->features   |= NETIF_F_GSO_SOFTWARE;
2572

2573 2574
	dev->vlan_features = dev->features;
	dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
2575
	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
2576
	dev->hw_features |= NETIF_F_GSO_SOFTWARE;
2577
	dev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
2578
	netif_keep_dst(dev);
2579
	dev->priv_flags |= IFF_NO_QUEUE;
S
stephen hemminger 已提交
2580

2581
	INIT_LIST_HEAD(&vxlan->next);
S
stephen hemminger 已提交
2582 2583 2584 2585 2586 2587
	spin_lock_init(&vxlan->hash_lock);

	init_timer_deferrable(&vxlan->age_timer);
	vxlan->age_timer.function = vxlan_cleanup;
	vxlan->age_timer.data = (unsigned long) vxlan;

2588
	vxlan->cfg.dst_port = htons(vxlan_port);
2589

S
stephen hemminger 已提交
2590 2591
	vxlan->dev = dev;

T
Tom Herbert 已提交
2592 2593
	gro_cells_init(&vxlan->gro_cells, dev);

S
stephen hemminger 已提交
2594 2595 2596 2597
	for (h = 0; h < FDB_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&vxlan->fdb_head[h]);
}

2598 2599 2600 2601 2602 2603 2604
static void vxlan_ether_setup(struct net_device *dev)
{
	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
	dev->netdev_ops = &vxlan_netdev_ether_ops;
}

J
Jiri Benc 已提交
2605 2606
static void vxlan_raw_setup(struct net_device *dev)
{
2607
	dev->header_ops = NULL;
J
Jiri Benc 已提交
2608 2609 2610 2611 2612 2613 2614
	dev->type = ARPHRD_NONE;
	dev->hard_header_len = 0;
	dev->addr_len = 0;
	dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
	dev->netdev_ops = &vxlan_netdev_raw_ops;
}

S
stephen hemminger 已提交
2615 2616
static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
	[IFLA_VXLAN_ID]		= { .type = NLA_U32 },
2617
	[IFLA_VXLAN_GROUP]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
C
Cong Wang 已提交
2618
	[IFLA_VXLAN_GROUP6]	= { .len = sizeof(struct in6_addr) },
S
stephen hemminger 已提交
2619 2620
	[IFLA_VXLAN_LINK]	= { .type = NLA_U32 },
	[IFLA_VXLAN_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
C
Cong Wang 已提交
2621
	[IFLA_VXLAN_LOCAL6]	= { .len = sizeof(struct in6_addr) },
S
stephen hemminger 已提交
2622 2623
	[IFLA_VXLAN_TOS]	= { .type = NLA_U8 },
	[IFLA_VXLAN_TTL]	= { .type = NLA_U8 },
2624
	[IFLA_VXLAN_LABEL]	= { .type = NLA_U32 },
S
stephen hemminger 已提交
2625 2626 2627
	[IFLA_VXLAN_LEARNING]	= { .type = NLA_U8 },
	[IFLA_VXLAN_AGEING]	= { .type = NLA_U32 },
	[IFLA_VXLAN_LIMIT]	= { .type = NLA_U32 },
2628
	[IFLA_VXLAN_PORT_RANGE] = { .len  = sizeof(struct ifla_vxlan_port_range) },
D
David Stevens 已提交
2629 2630 2631 2632
	[IFLA_VXLAN_PROXY]	= { .type = NLA_U8 },
	[IFLA_VXLAN_RSC]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L2MISS]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L3MISS]	= { .type = NLA_U8 },
2633
	[IFLA_VXLAN_COLLECT_METADATA]	= { .type = NLA_U8 },
2634
	[IFLA_VXLAN_PORT]	= { .type = NLA_U16 },
2635 2636 2637
	[IFLA_VXLAN_UDP_CSUM]	= { .type = NLA_U8 },
	[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]	= { .type = NLA_U8 },
	[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]	= { .type = NLA_U8 },
T
Tom Herbert 已提交
2638 2639
	[IFLA_VXLAN_REMCSUM_TX]	= { .type = NLA_U8 },
	[IFLA_VXLAN_REMCSUM_RX]	= { .type = NLA_U8 },
T
Thomas Graf 已提交
2640
	[IFLA_VXLAN_GBP]	= { .type = NLA_FLAG, },
J
Jiri Benc 已提交
2641
	[IFLA_VXLAN_GPE]	= { .type = NLA_FLAG, },
2642
	[IFLA_VXLAN_REMCSUM_NOPARTIAL]	= { .type = NLA_FLAG },
S
stephen hemminger 已提交
2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667
};

static int vxlan_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {
			pr_debug("invalid link address (not ethernet)\n");
			return -EINVAL;
		}

		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {
			pr_debug("invalid all zero ethernet address\n");
			return -EADDRNOTAVAIL;
		}
	}

	if (!data)
		return -EINVAL;

	if (data[IFLA_VXLAN_ID]) {
		__u32 id = nla_get_u32(data[IFLA_VXLAN_ID]);
		if (id >= VXLAN_VID_MASK)
			return -ERANGE;
	}

2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678
	if (data[IFLA_VXLAN_PORT_RANGE]) {
		const struct ifla_vxlan_port_range *p
			= nla_data(data[IFLA_VXLAN_PORT_RANGE]);

		if (ntohs(p->high) < ntohs(p->low)) {
			pr_debug("port range %u .. %u not valid\n",
				 ntohs(p->low), ntohs(p->high));
			return -EINVAL;
		}
	}

S
stephen hemminger 已提交
2679 2680 2681
	return 0;
}

Y
Yan Burman 已提交
2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693
static void vxlan_get_drvinfo(struct net_device *netdev,
			      struct ethtool_drvinfo *drvinfo)
{
	strlcpy(drvinfo->version, VXLAN_VERSION, sizeof(drvinfo->version));
	strlcpy(drvinfo->driver, "vxlan", sizeof(drvinfo->driver));
}

static const struct ethtool_ops vxlan_ethtool_ops = {
	.get_drvinfo	= vxlan_get_drvinfo,
	.get_link	= ethtool_op_get_link,
};

T
Tom Herbert 已提交
2694 2695
static struct socket *vxlan_create_sock(struct net *net, bool ipv6,
					__be16 port, u32 flags)
2696
{
C
Cong Wang 已提交
2697
	struct socket *sock;
T
Tom Herbert 已提交
2698 2699
	struct udp_port_cfg udp_conf;
	int err;
C
Cong Wang 已提交
2700

T
Tom Herbert 已提交
2701
	memset(&udp_conf, 0, sizeof(udp_conf));
C
Cong Wang 已提交
2702

T
Tom Herbert 已提交
2703 2704 2705
	if (ipv6) {
		udp_conf.family = AF_INET6;
		udp_conf.use_udp6_rx_checksums =
2706
		    !(flags & VXLAN_F_UDP_ZERO_CSUM6_RX);
2707
		udp_conf.ipv6_v6only = 1;
T
Tom Herbert 已提交
2708 2709
	} else {
		udp_conf.family = AF_INET;
C
Cong Wang 已提交
2710 2711
	}

T
Tom Herbert 已提交
2712
	udp_conf.local_udp_port = port;
2713

T
Tom Herbert 已提交
2714 2715 2716 2717
	/* Open UDP socket */
	err = udp_sock_create(net, &udp_conf, &sock);
	if (err < 0)
		return ERR_PTR(err);
C
Cong Wang 已提交
2718

Z
Zhi Yong Wu 已提交
2719
	return sock;
C
Cong Wang 已提交
2720 2721 2722
}

/* Create new listen socket if needed */
2723 2724
static struct vxlan_sock *vxlan_socket_create(struct net *net, bool ipv6,
					      __be16 port, u32 flags)
C
Cong Wang 已提交
2725 2726 2727 2728 2729
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
	struct vxlan_sock *vs;
	struct socket *sock;
	unsigned int h;
2730
	struct udp_tunnel_sock_cfg tunnel_cfg;
C
Cong Wang 已提交
2731

2732
	vs = kzalloc(sizeof(*vs), GFP_KERNEL);
C
Cong Wang 已提交
2733 2734 2735 2736 2737 2738
	if (!vs)
		return ERR_PTR(-ENOMEM);

	for (h = 0; h < VNI_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&vs->vni_list[h]);

T
Tom Herbert 已提交
2739
	sock = vxlan_create_sock(net, ipv6, port, flags);
Z
Zhi Yong Wu 已提交
2740
	if (IS_ERR(sock)) {
2741 2742
		pr_info("Cannot bind port %d, err=%ld\n", ntohs(port),
			PTR_ERR(sock));
2743
		kfree(vs);
2744
		return ERR_CAST(sock);
2745
	}
C
Cong Wang 已提交
2746 2747

	vs->sock = sock;
2748
	atomic_set(&vs->refcnt, 1);
2749
	vs->flags = (flags & VXLAN_F_RCV_FLAGS);
2750

2751 2752
	spin_lock(&vn->sock_lock);
	hlist_add_head_rcu(&vs->hlist, vs_head(net, port));
2753
	vxlan_notify_add_rx_port(vs);
2754
	spin_unlock(&vn->sock_lock);
2755 2756

	/* Mark socket as an encapsulation socket. */
2757
	memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
2758 2759
	tunnel_cfg.sk_user_data = vs;
	tunnel_cfg.encap_type = 1;
2760
	tunnel_cfg.encap_rcv = vxlan_rcv;
2761
	tunnel_cfg.encap_destroy = NULL;
2762 2763
	tunnel_cfg.gro_receive = vxlan_gro_receive;
	tunnel_cfg.gro_complete = vxlan_gro_complete;
2764 2765

	setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
C
Cong Wang 已提交
2766

2767 2768 2769
	return vs;
}

2770
static int __vxlan_sock_add(struct vxlan_dev *vxlan, bool ipv6)
2771
{
2772 2773
	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
	struct vxlan_sock *vs = NULL;
2774

2775
	if (!vxlan->cfg.no_share) {
2776
		spin_lock(&vn->sock_lock);
2777 2778 2779
		vs = vxlan_find_sock(vxlan->net, ipv6 ? AF_INET6 : AF_INET,
				     vxlan->cfg.dst_port, vxlan->flags);
		if (vs && !atomic_add_unless(&vs->refcnt, 1, 0)) {
2780
			spin_unlock(&vn->sock_lock);
2781
			return -EBUSY;
2782 2783 2784
		}
		spin_unlock(&vn->sock_lock);
	}
2785
	if (!vs)
2786 2787
		vs = vxlan_socket_create(vxlan->net, ipv6,
					 vxlan->cfg.dst_port, vxlan->flags);
2788 2789
	if (IS_ERR(vs))
		return PTR_ERR(vs);
2790 2791 2792 2793 2794 2795
#if IS_ENABLED(CONFIG_IPV6)
	if (ipv6)
		vxlan->vn6_sock = vs;
	else
#endif
		vxlan->vn4_sock = vs;
2796 2797
	vxlan_vs_add_dev(vs, vxlan);
	return 0;
2798 2799
}

2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818
static int vxlan_sock_add(struct vxlan_dev *vxlan)
{
	bool ipv6 = vxlan->flags & VXLAN_F_IPV6;
	bool metadata = vxlan->flags & VXLAN_F_COLLECT_METADATA;
	int ret = 0;

	vxlan->vn4_sock = NULL;
#if IS_ENABLED(CONFIG_IPV6)
	vxlan->vn6_sock = NULL;
	if (ipv6 || metadata)
		ret = __vxlan_sock_add(vxlan, true);
#endif
	if (!ret && (!ipv6 || metadata))
		ret = __vxlan_sock_add(vxlan, false);
	if (ret < 0)
		vxlan_sock_release(vxlan);
	return ret;
}

2819 2820
static int vxlan_dev_configure(struct net *src_net, struct net_device *dev,
			       struct vxlan_config *conf)
S
stephen hemminger 已提交
2821
{
2822
	struct vxlan_net *vn = net_generic(src_net, vxlan_net_id);
2823
	struct vxlan_dev *vxlan = netdev_priv(dev), *tmp;
2824
	struct vxlan_rdst *dst = &vxlan->default_dst;
2825
	unsigned short needed_headroom = ETH_HLEN;
S
stephen hemminger 已提交
2826
	int err;
C
Cong Wang 已提交
2827
	bool use_ipv6 = false;
2828
	__be16 default_port = vxlan->cfg.dst_port;
2829
	struct net_device *lowerdev = NULL;
S
stephen hemminger 已提交
2830

J
Jiri Benc 已提交
2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
	if (conf->flags & VXLAN_F_GPE) {
		if (conf->flags & ~VXLAN_F_ALLOWED_GPE)
			return -EINVAL;
		/* For now, allow GPE only together with COLLECT_METADATA.
		 * This can be relaxed later; in such case, the other side
		 * of the PtP link will have to be provided.
		 */
		if (!(conf->flags & VXLAN_F_COLLECT_METADATA))
			return -EINVAL;

		vxlan_raw_setup(dev);
	} else {
		vxlan_ether_setup(dev);
	}
2845

2846
	vxlan->net = src_net;
N
Nicolas Dichtel 已提交
2847

2848
	dst->remote_vni = conf->vni;
S
stephen hemminger 已提交
2849

2850
	memcpy(&dst->remote_ip, &conf->remote_ip, sizeof(conf->remote_ip));
S
stephen hemminger 已提交
2851

2852 2853 2854
	/* Unless IPv6 is explicitly requested, assume IPv4 */
	if (!dst->remote_ip.sa.sa_family)
		dst->remote_ip.sa.sa_family = AF_INET;
C
Cong Wang 已提交
2855

2856
	if (dst->remote_ip.sa.sa_family == AF_INET6 ||
2857 2858 2859
	    vxlan->cfg.saddr.sa.sa_family == AF_INET6) {
		if (!IS_ENABLED(CONFIG_IPV6))
			return -EPFNOSUPPORT;
C
Cong Wang 已提交
2860
		use_ipv6 = true;
2861
		vxlan->flags |= VXLAN_F_IPV6;
2862
	}
S
stephen hemminger 已提交
2863

2864 2865 2866 2867 2868
	if (conf->label && !use_ipv6) {
		pr_info("label only supported in use with IPv6\n");
		return -EINVAL;
	}

2869
	if (conf->remote_ifindex) {
2870
		lowerdev = __dev_get_by_index(src_net, conf->remote_ifindex);
2871
		dst->remote_ifindex = conf->remote_ifindex;
2872 2873

		if (!lowerdev) {
2874
			pr_info("ifindex %d does not exist\n", dst->remote_ifindex);
2875 2876
			return -ENODEV;
		}
S
stephen hemminger 已提交
2877

C
Cong Wang 已提交
2878 2879 2880 2881 2882 2883 2884 2885 2886 2887
#if IS_ENABLED(CONFIG_IPV6)
		if (use_ipv6) {
			struct inet6_dev *idev = __in6_dev_get(lowerdev);
			if (idev && idev->cnf.disable_ipv6) {
				pr_info("IPv6 is disabled via sysctl\n");
				return -EPERM;
			}
		}
#endif

2888
		if (!conf->mtu)
C
Cong Wang 已提交
2889
			dev->mtu = lowerdev->mtu - (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
2890

2891
		needed_headroom = lowerdev->hard_header_len;
J
Jiri Benc 已提交
2892
	}
S
stephen hemminger 已提交
2893

2894 2895 2896 2897 2898 2899
	if (conf->mtu) {
		err = __vxlan_change_mtu(dev, lowerdev, dst, conf->mtu, false);
		if (err)
			return err;
	}

2900 2901 2902 2903 2904 2905
	if (use_ipv6 || conf->flags & VXLAN_F_COLLECT_METADATA)
		needed_headroom += VXLAN6_HEADROOM;
	else
		needed_headroom += VXLAN_HEADROOM;
	dev->needed_headroom = needed_headroom;

2906
	memcpy(&vxlan->cfg, conf, sizeof(*conf));
J
Jiri Benc 已提交
2907 2908 2909 2910 2911 2912
	if (!vxlan->cfg.dst_port) {
		if (conf->flags & VXLAN_F_GPE)
			vxlan->cfg.dst_port = 4790; /* IANA assigned VXLAN-GPE port */
		else
			vxlan->cfg.dst_port = default_port;
	}
2913 2914 2915 2916 2917
	vxlan->flags |= conf->flags;

	if (!vxlan->cfg.age_interval)
		vxlan->cfg.age_interval = FDB_AGE_DEFAULT;

2918 2919 2920 2921 2922 2923 2924
	list_for_each_entry(tmp, &vn->vxlan_list, next) {
		if (tmp->cfg.vni == conf->vni &&
		    (tmp->default_dst.remote_ip.sa.sa_family == AF_INET6 ||
		     tmp->cfg.saddr.sa.sa_family == AF_INET6) == use_ipv6 &&
		    tmp->cfg.dst_port == vxlan->cfg.dst_port &&
		    (tmp->flags & VXLAN_F_RCV_FLAGS) ==
		    (vxlan->flags & VXLAN_F_RCV_FLAGS))
2925
		return -EEXIST;
2926
	}
2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985

	dev->ethtool_ops = &vxlan_ethtool_ops;

	/* create an fdb entry for a valid default destination */
	if (!vxlan_addr_any(&vxlan->default_dst.remote_ip)) {
		err = vxlan_fdb_create(vxlan, all_zeros_mac,
				       &vxlan->default_dst.remote_ip,
				       NUD_REACHABLE|NUD_PERMANENT,
				       NLM_F_EXCL|NLM_F_CREATE,
				       vxlan->cfg.dst_port,
				       vxlan->default_dst.remote_vni,
				       vxlan->default_dst.remote_ifindex,
				       NTF_SELF);
		if (err)
			return err;
	}

	err = register_netdevice(dev);
	if (err) {
		vxlan_fdb_delete_default(vxlan);
		return err;
	}

	list_add(&vxlan->next, &vn->vxlan_list);

	return 0;
}

struct net_device *vxlan_dev_create(struct net *net, const char *name,
				    u8 name_assign_type, struct vxlan_config *conf)
{
	struct nlattr *tb[IFLA_MAX+1];
	struct net_device *dev;
	int err;

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

	dev = rtnl_create_link(net, name, name_assign_type,
			       &vxlan_link_ops, tb);
	if (IS_ERR(dev))
		return dev;

	err = vxlan_dev_configure(net, dev, conf);
	if (err < 0) {
		free_netdev(dev);
		return ERR_PTR(err);
	}

	return dev;
}
EXPORT_SYMBOL_GPL(vxlan_dev_create);

static int vxlan_newlink(struct net *src_net, struct net_device *dev,
			 struct nlattr *tb[], struct nlattr *data[])
{
	struct vxlan_config conf;
	int err;

	memset(&conf, 0, sizeof(conf));
2986 2987

	if (data[IFLA_VXLAN_ID])
2988
		conf.vni = cpu_to_be32(nla_get_u32(data[IFLA_VXLAN_ID]));
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014

	if (data[IFLA_VXLAN_GROUP]) {
		conf.remote_ip.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_GROUP]);
	} else if (data[IFLA_VXLAN_GROUP6]) {
		if (!IS_ENABLED(CONFIG_IPV6))
			return -EPFNOSUPPORT;

		conf.remote_ip.sin6.sin6_addr = nla_get_in6_addr(data[IFLA_VXLAN_GROUP6]);
		conf.remote_ip.sa.sa_family = AF_INET6;
	}

	if (data[IFLA_VXLAN_LOCAL]) {
		conf.saddr.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_LOCAL]);
		conf.saddr.sa.sa_family = AF_INET;
	} else if (data[IFLA_VXLAN_LOCAL6]) {
		if (!IS_ENABLED(CONFIG_IPV6))
			return -EPFNOSUPPORT;

		/* TODO: respect scope id */
		conf.saddr.sin6.sin6_addr = nla_get_in6_addr(data[IFLA_VXLAN_LOCAL6]);
		conf.saddr.sa.sa_family = AF_INET6;
	}

	if (data[IFLA_VXLAN_LINK])
		conf.remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]);

S
stephen hemminger 已提交
3015
	if (data[IFLA_VXLAN_TOS])
3016
		conf.tos  = nla_get_u8(data[IFLA_VXLAN_TOS]);
S
stephen hemminger 已提交
3017

3018
	if (data[IFLA_VXLAN_TTL])
3019
		conf.ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);
3020

3021 3022 3023 3024
	if (data[IFLA_VXLAN_LABEL])
		conf.label = nla_get_be32(data[IFLA_VXLAN_LABEL]) &
			     IPV6_FLOWLABEL_MASK;

S
stephen hemminger 已提交
3025
	if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))
3026
		conf.flags |= VXLAN_F_LEARN;
S
stephen hemminger 已提交
3027 3028

	if (data[IFLA_VXLAN_AGEING])
3029
		conf.age_interval = nla_get_u32(data[IFLA_VXLAN_AGEING]);
S
stephen hemminger 已提交
3030

D
David Stevens 已提交
3031
	if (data[IFLA_VXLAN_PROXY] && nla_get_u8(data[IFLA_VXLAN_PROXY]))
3032
		conf.flags |= VXLAN_F_PROXY;
D
David Stevens 已提交
3033 3034

	if (data[IFLA_VXLAN_RSC] && nla_get_u8(data[IFLA_VXLAN_RSC]))
3035
		conf.flags |= VXLAN_F_RSC;
D
David Stevens 已提交
3036 3037

	if (data[IFLA_VXLAN_L2MISS] && nla_get_u8(data[IFLA_VXLAN_L2MISS]))
3038
		conf.flags |= VXLAN_F_L2MISS;
D
David Stevens 已提交
3039 3040

	if (data[IFLA_VXLAN_L3MISS] && nla_get_u8(data[IFLA_VXLAN_L3MISS]))
3041
		conf.flags |= VXLAN_F_L3MISS;
D
David Stevens 已提交
3042

S
stephen hemminger 已提交
3043
	if (data[IFLA_VXLAN_LIMIT])
3044
		conf.addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);
S
stephen hemminger 已提交
3045

3046 3047 3048 3049
	if (data[IFLA_VXLAN_COLLECT_METADATA] &&
	    nla_get_u8(data[IFLA_VXLAN_COLLECT_METADATA]))
		conf.flags |= VXLAN_F_COLLECT_METADATA;

3050 3051 3052
	if (data[IFLA_VXLAN_PORT_RANGE]) {
		const struct ifla_vxlan_port_range *p
			= nla_data(data[IFLA_VXLAN_PORT_RANGE]);
3053 3054
		conf.port_min = ntohs(p->low);
		conf.port_max = ntohs(p->high);
3055 3056
	}

3057
	if (data[IFLA_VXLAN_PORT])
3058
		conf.dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);
3059

3060 3061 3062
	if (data[IFLA_VXLAN_UDP_CSUM] &&
	    !nla_get_u8(data[IFLA_VXLAN_UDP_CSUM]))
		conf.flags |= VXLAN_F_UDP_ZERO_CSUM_TX;
3063 3064 3065

	if (data[IFLA_VXLAN_UDP_ZERO_CSUM6_TX] &&
	    nla_get_u8(data[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]))
3066
		conf.flags |= VXLAN_F_UDP_ZERO_CSUM6_TX;
3067 3068 3069

	if (data[IFLA_VXLAN_UDP_ZERO_CSUM6_RX] &&
	    nla_get_u8(data[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]))
3070
		conf.flags |= VXLAN_F_UDP_ZERO_CSUM6_RX;
3071

T
Tom Herbert 已提交
3072 3073
	if (data[IFLA_VXLAN_REMCSUM_TX] &&
	    nla_get_u8(data[IFLA_VXLAN_REMCSUM_TX]))
3074
		conf.flags |= VXLAN_F_REMCSUM_TX;
T
Tom Herbert 已提交
3075 3076 3077

	if (data[IFLA_VXLAN_REMCSUM_RX] &&
	    nla_get_u8(data[IFLA_VXLAN_REMCSUM_RX]))
3078
		conf.flags |= VXLAN_F_REMCSUM_RX;
T
Tom Herbert 已提交
3079

T
Thomas Graf 已提交
3080
	if (data[IFLA_VXLAN_GBP])
3081
		conf.flags |= VXLAN_F_GBP;
T
Thomas Graf 已提交
3082

J
Jiri Benc 已提交
3083 3084 3085
	if (data[IFLA_VXLAN_GPE])
		conf.flags |= VXLAN_F_GPE;

3086
	if (data[IFLA_VXLAN_REMCSUM_NOPARTIAL])
3087
		conf.flags |= VXLAN_F_REMCSUM_NOPARTIAL;
3088

3089 3090 3091
	if (tb[IFLA_MTU])
		conf.mtu = nla_get_u32(tb[IFLA_MTU]);

3092 3093 3094 3095 3096
	err = vxlan_dev_configure(src_net, dev, &conf);
	switch (err) {
	case -ENODEV:
		pr_info("ifindex %d does not exist\n", conf.remote_ifindex);
		break;
Y
Yan Burman 已提交
3097

3098 3099 3100
	case -EPERM:
		pr_info("IPv6 is disabled via sysctl\n");
		break;
S
stephen hemminger 已提交
3101

3102
	case -EEXIST:
3103
		pr_info("duplicate VNI %u\n", be32_to_cpu(conf.vni));
3104
		break;
J
Jiri Benc 已提交
3105 3106 3107 3108

	case -EINVAL:
		pr_info("unsupported combination of extensions\n");
		break;
3109 3110
	}

3111
	return err;
S
stephen hemminger 已提交
3112 3113 3114 3115 3116
}

static void vxlan_dellink(struct net_device *dev, struct list_head *head)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
N
Nicolas Dichtel 已提交
3117
	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
S
stephen hemminger 已提交
3118

3119
	spin_lock(&vn->sock_lock);
3120 3121
	if (!hlist_unhashed(&vxlan->hlist))
		hlist_del_rcu(&vxlan->hlist);
3122 3123
	spin_unlock(&vn->sock_lock);

T
Tom Herbert 已提交
3124
	gro_cells_destroy(&vxlan->gro_cells);
3125
	list_del(&vxlan->next);
S
stephen hemminger 已提交
3126 3127 3128 3129 3130 3131 3132
	unregister_netdevice_queue(dev, head);
}

static size_t vxlan_get_size(const struct net_device *dev)
{

	return nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_ID */
C
Cong Wang 已提交
3133
		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */
S
stephen hemminger 已提交
3134
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LINK */
C
Cong Wang 已提交
3135
		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */
S
stephen hemminger 已提交
3136 3137
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TTL */
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TOS */
3138
		nla_total_size(sizeof(__be32)) + /* IFLA_VXLAN_LABEL */
S
stephen hemminger 已提交
3139
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_LEARNING */
D
David Stevens 已提交
3140 3141 3142 3143
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_PROXY */
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_RSC */
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_L2MISS */
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_L3MISS */
3144
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_COLLECT_METADATA */
S
stephen hemminger 已提交
3145 3146
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_AGEING */
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LIMIT */
3147
		nla_total_size(sizeof(struct ifla_vxlan_port_range)) +
3148 3149 3150 3151
		nla_total_size(sizeof(__be16)) + /* IFLA_VXLAN_PORT */
		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_CSUM */
		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_ZERO_CSUM6_TX */
		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_ZERO_CSUM6_RX */
T
Tom Herbert 已提交
3152 3153
		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_TX */
		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_RX */
S
stephen hemminger 已提交
3154 3155 3156 3157 3158 3159
		0;
}

static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
{
	const struct vxlan_dev *vxlan = netdev_priv(dev);
3160
	const struct vxlan_rdst *dst = &vxlan->default_dst;
3161
	struct ifla_vxlan_port_range ports = {
3162 3163
		.low =  htons(vxlan->cfg.port_min),
		.high = htons(vxlan->cfg.port_max),
3164
	};
S
stephen hemminger 已提交
3165

3166
	if (nla_put_u32(skb, IFLA_VXLAN_ID, be32_to_cpu(dst->remote_vni)))
S
stephen hemminger 已提交
3167 3168
		goto nla_put_failure;

C
Cong Wang 已提交
3169 3170
	if (!vxlan_addr_any(&dst->remote_ip)) {
		if (dst->remote_ip.sa.sa_family == AF_INET) {
3171 3172
			if (nla_put_in_addr(skb, IFLA_VXLAN_GROUP,
					    dst->remote_ip.sin.sin_addr.s_addr))
C
Cong Wang 已提交
3173 3174 3175
				goto nla_put_failure;
#if IS_ENABLED(CONFIG_IPV6)
		} else {
3176 3177
			if (nla_put_in6_addr(skb, IFLA_VXLAN_GROUP6,
					     &dst->remote_ip.sin6.sin6_addr))
C
Cong Wang 已提交
3178 3179 3180 3181
				goto nla_put_failure;
#endif
		}
	}
S
stephen hemminger 已提交
3182

3183
	if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))
S
stephen hemminger 已提交
3184 3185
		goto nla_put_failure;

3186 3187
	if (!vxlan_addr_any(&vxlan->cfg.saddr)) {
		if (vxlan->cfg.saddr.sa.sa_family == AF_INET) {
3188
			if (nla_put_in_addr(skb, IFLA_VXLAN_LOCAL,
3189
					    vxlan->cfg.saddr.sin.sin_addr.s_addr))
C
Cong Wang 已提交
3190 3191 3192
				goto nla_put_failure;
#if IS_ENABLED(CONFIG_IPV6)
		} else {
3193
			if (nla_put_in6_addr(skb, IFLA_VXLAN_LOCAL6,
3194
					     &vxlan->cfg.saddr.sin6.sin6_addr))
C
Cong Wang 已提交
3195 3196 3197 3198
				goto nla_put_failure;
#endif
		}
	}
S
stephen hemminger 已提交
3199

3200 3201
	if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->cfg.ttl) ||
	    nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->cfg.tos) ||
3202
	    nla_put_be32(skb, IFLA_VXLAN_LABEL, vxlan->cfg.label) ||
D
David Stevens 已提交
3203 3204 3205 3206 3207 3208 3209 3210 3211
	    nla_put_u8(skb, IFLA_VXLAN_LEARNING,
			!!(vxlan->flags & VXLAN_F_LEARN)) ||
	    nla_put_u8(skb, IFLA_VXLAN_PROXY,
			!!(vxlan->flags & VXLAN_F_PROXY)) ||
	    nla_put_u8(skb, IFLA_VXLAN_RSC, !!(vxlan->flags & VXLAN_F_RSC)) ||
	    nla_put_u8(skb, IFLA_VXLAN_L2MISS,
			!!(vxlan->flags & VXLAN_F_L2MISS)) ||
	    nla_put_u8(skb, IFLA_VXLAN_L3MISS,
			!!(vxlan->flags & VXLAN_F_L3MISS)) ||
3212 3213
	    nla_put_u8(skb, IFLA_VXLAN_COLLECT_METADATA,
		       !!(vxlan->flags & VXLAN_F_COLLECT_METADATA)) ||
3214 3215 3216
	    nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->cfg.age_interval) ||
	    nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->cfg.addrmax) ||
	    nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->cfg.dst_port) ||
3217
	    nla_put_u8(skb, IFLA_VXLAN_UDP_CSUM,
3218
			!(vxlan->flags & VXLAN_F_UDP_ZERO_CSUM_TX)) ||
3219 3220 3221
	    nla_put_u8(skb, IFLA_VXLAN_UDP_ZERO_CSUM6_TX,
			!!(vxlan->flags & VXLAN_F_UDP_ZERO_CSUM6_TX)) ||
	    nla_put_u8(skb, IFLA_VXLAN_UDP_ZERO_CSUM6_RX,
T
Tom Herbert 已提交
3222 3223 3224 3225 3226
			!!(vxlan->flags & VXLAN_F_UDP_ZERO_CSUM6_RX)) ||
	    nla_put_u8(skb, IFLA_VXLAN_REMCSUM_TX,
			!!(vxlan->flags & VXLAN_F_REMCSUM_TX)) ||
	    nla_put_u8(skb, IFLA_VXLAN_REMCSUM_RX,
			!!(vxlan->flags & VXLAN_F_REMCSUM_RX)))
S
stephen hemminger 已提交
3227 3228
		goto nla_put_failure;

3229 3230 3231
	if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))
		goto nla_put_failure;

T
Thomas Graf 已提交
3232 3233 3234 3235
	if (vxlan->flags & VXLAN_F_GBP &&
	    nla_put_flag(skb, IFLA_VXLAN_GBP))
		goto nla_put_failure;

J
Jiri Benc 已提交
3236 3237 3238 3239
	if (vxlan->flags & VXLAN_F_GPE &&
	    nla_put_flag(skb, IFLA_VXLAN_GPE))
		goto nla_put_failure;

3240 3241 3242 3243
	if (vxlan->flags & VXLAN_F_REMCSUM_NOPARTIAL &&
	    nla_put_flag(skb, IFLA_VXLAN_REMCSUM_NOPARTIAL))
		goto nla_put_failure;

S
stephen hemminger 已提交
3244 3245 3246 3247 3248 3249
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

3250 3251 3252 3253 3254 3255 3256
static struct net *vxlan_get_link_net(const struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);

	return vxlan->net;
}

S
stephen hemminger 已提交
3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267
static struct rtnl_link_ops vxlan_link_ops __read_mostly = {
	.kind		= "vxlan",
	.maxtype	= IFLA_VXLAN_MAX,
	.policy		= vxlan_policy,
	.priv_size	= sizeof(struct vxlan_dev),
	.setup		= vxlan_setup,
	.validate	= vxlan_validate,
	.newlink	= vxlan_newlink,
	.dellink	= vxlan_dellink,
	.get_size	= vxlan_get_size,
	.fill_info	= vxlan_fill_info,
3268
	.get_link_net	= vxlan_get_link_net,
S
stephen hemminger 已提交
3269 3270
};

3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292
static void vxlan_handle_lowerdev_unregister(struct vxlan_net *vn,
					     struct net_device *dev)
{
	struct vxlan_dev *vxlan, *next;
	LIST_HEAD(list_kill);

	list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next) {
		struct vxlan_rdst *dst = &vxlan->default_dst;

		/* In case we created vxlan device with carrier
		 * and we loose the carrier due to module unload
		 * we also need to remove vxlan device. In other
		 * cases, it's not necessary and remote_ifindex
		 * is 0 here, so no matches.
		 */
		if (dst->remote_ifindex == dev->ifindex)
			vxlan_dellink(vxlan->dev, &list_kill);
	}

	unregister_netdevice_many(&list_kill);
}

3293 3294
static int vxlan_netdevice_event(struct notifier_block *unused,
				 unsigned long event, void *ptr)
3295 3296
{
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3297
	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
3298

3299
	if (event == NETDEV_UNREGISTER)
3300
		vxlan_handle_lowerdev_unregister(vn, dev);
3301 3302
	else if (event == NETDEV_OFFLOAD_PUSH_VXLAN)
		vxlan_push_rx_ports(dev);
3303 3304 3305 3306 3307

	return NOTIFY_DONE;
}

static struct notifier_block vxlan_notifier_block __read_mostly = {
3308
	.notifier_call = vxlan_netdevice_event,
3309 3310
};

S
stephen hemminger 已提交
3311 3312 3313
static __net_init int vxlan_init_net(struct net *net)
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
3314
	unsigned int h;
S
stephen hemminger 已提交
3315

3316
	INIT_LIST_HEAD(&vn->vxlan_list);
3317
	spin_lock_init(&vn->sock_lock);
S
stephen hemminger 已提交
3318

3319 3320
	for (h = 0; h < PORT_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&vn->sock_list[h]);
S
stephen hemminger 已提交
3321 3322 3323 3324

	return 0;
}

N
Nicolas Dichtel 已提交
3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340
static void __net_exit vxlan_exit_net(struct net *net)
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
	struct vxlan_dev *vxlan, *next;
	struct net_device *dev, *aux;
	LIST_HEAD(list);

	rtnl_lock();
	for_each_netdev_safe(net, dev, aux)
		if (dev->rtnl_link_ops == &vxlan_link_ops)
			unregister_netdevice_queue(dev, &list);

	list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next) {
		/* If vxlan->dev is in the same netns, it has already been added
		 * to the list by the previous loop.
		 */
T
Tom Herbert 已提交
3341 3342
		if (!net_eq(dev_net(vxlan->dev), net)) {
			gro_cells_destroy(&vxlan->gro_cells);
3343
			unregister_netdevice_queue(vxlan->dev, &list);
T
Tom Herbert 已提交
3344
		}
N
Nicolas Dichtel 已提交
3345 3346 3347 3348 3349 3350
	}

	unregister_netdevice_many(&list);
	rtnl_unlock();
}

S
stephen hemminger 已提交
3351 3352
static struct pernet_operations vxlan_net_ops = {
	.init = vxlan_init_net,
N
Nicolas Dichtel 已提交
3353
	.exit = vxlan_exit_net,
S
stephen hemminger 已提交
3354 3355 3356 3357 3358 3359 3360 3361 3362 3363
	.id   = &vxlan_net_id,
	.size = sizeof(struct vxlan_net),
};

static int __init vxlan_init_module(void)
{
	int rc;

	get_random_bytes(&vxlan_salt, sizeof(vxlan_salt));

3364
	rc = register_pernet_subsys(&vxlan_net_ops);
S
stephen hemminger 已提交
3365 3366 3367
	if (rc)
		goto out1;

3368
	rc = register_netdevice_notifier(&vxlan_notifier_block);
S
stephen hemminger 已提交
3369 3370 3371
	if (rc)
		goto out2;

3372 3373 3374
	rc = rtnl_link_register(&vxlan_link_ops);
	if (rc)
		goto out3;
S
stephen hemminger 已提交
3375

3376 3377 3378
	return 0;
out3:
	unregister_netdevice_notifier(&vxlan_notifier_block);
S
stephen hemminger 已提交
3379
out2:
3380
	unregister_pernet_subsys(&vxlan_net_ops);
S
stephen hemminger 已提交
3381 3382 3383
out1:
	return rc;
}
3384
late_initcall(vxlan_init_module);
S
stephen hemminger 已提交
3385 3386 3387

static void __exit vxlan_cleanup_module(void)
{
3388
	rtnl_link_unregister(&vxlan_link_ops);
3389
	unregister_netdevice_notifier(&vxlan_notifier_block);
3390 3391
	unregister_pernet_subsys(&vxlan_net_ops);
	/* rcu_barrier() is called by netns */
S
stephen hemminger 已提交
3392 3393 3394 3395 3396
}
module_exit(vxlan_cleanup_module);

MODULE_LICENSE("GPL");
MODULE_VERSION(VXLAN_VERSION);
3397
MODULE_AUTHOR("Stephen Hemminger <stephen@networkplumber.org>");
J
Jesse Brandeburg 已提交
3398
MODULE_DESCRIPTION("Driver for VXLAN encapsulated traffic");
S
stephen hemminger 已提交
3399
MODULE_ALIAS_RTNL_LINK("vxlan");