vxlan.c 84.8 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
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/udp.h>
#include <linux/igmp.h>
#include <linux/if_ether.h>
Y
Yan Burman 已提交
20
#include <linux/ethtool.h>
D
David Stevens 已提交
21 22
#include <net/arp.h>
#include <net/ndisc.h>
S
stephen hemminger 已提交
23 24 25 26 27 28
#include <net/ip.h>
#include <net/icmp.h>
#include <net/rtnetlink.h>
#include <net/inet_ecn.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
29
#include <net/vxlan.h>
30

C
Cong Wang 已提交
31 32
#if IS_ENABLED(CONFIG_IPV6)
#include <net/ip6_tunnel.h>
33
#include <net/ip6_checksum.h>
C
Cong Wang 已提交
34
#endif
S
stephen hemminger 已提交
35 36 37

#define VXLAN_VERSION	"0.1"

38 39
#define PORT_HASH_BITS	8
#define PORT_HASH_SIZE  (1<<PORT_HASH_BITS)
S
stephen hemminger 已提交
40 41 42
#define FDB_AGE_DEFAULT 300 /* 5 min */
#define FDB_AGE_INTERVAL (10 * HZ)	/* rescan interval */

43 44
/* UDP port for VXLAN traffic.
 * The IANA assigned port is 4789, but the Linux default is 8472
S
Stephen Hemminger 已提交
45
 * for compatibility with early adopters.
46
 */
47 48
static unsigned short vxlan_port __read_mostly = 8472;
module_param_named(udp_port, vxlan_port, ushort, 0444);
S
stephen hemminger 已提交
49 50 51 52 53 54
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");

55
static unsigned int vxlan_net_id;
56
static struct rtnl_link_ops vxlan_link_ops;
57

58
static const u8 all_zeros_mac[ETH_ALEN + 2];
59

60
static int vxlan_sock_add(struct vxlan_dev *vxlan);
61

62 63 64 65
/* per-network namespace private data for this module */
struct vxlan_net {
	struct list_head  vxlan_list;
	struct hlist_head sock_list[PORT_HASH_SIZE];
66
	spinlock_t	  sock_lock;
67 68
};

S
stephen hemminger 已提交
69 70 71 72 73 74
/* 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;
75
	struct list_head  remotes;
76
	u8		  eth_addr[ETH_ALEN];
S
stephen hemminger 已提交
77
	u16		  state;	/* see ndm_state */
78
	u8		  flags;	/* see ndm_flags */
S
stephen hemminger 已提交
79 80 81 82 83
};

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

T
Thomas Graf 已提交
84 85
static inline bool vxlan_collect_metadata(struct vxlan_sock *vs)
{
86 87
	return vs->flags & VXLAN_F_COLLECT_METADATA ||
	       ip_tunnel_collect_metadata();
T
Thomas Graf 已提交
88 89
}

C
Cong Wang 已提交
90 91 92 93
#if IS_ENABLED(CONFIG_IPV6)
static inline
bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
{
J
Jiri Benc 已提交
94 95 96 97 98 99
	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 已提交
100 101 102 103
}

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
{
J
Jiri Benc 已提交
104 105 106 107
	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 已提交
108 109 110 111
}

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
{
J
Jiri Benc 已提交
112 113 114 115
	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 已提交
116 117 118 119
}

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
{
J
Jiri Benc 已提交
120
	if (nla_len(nla) >= sizeof(struct in6_addr)) {
121
		ip->sin6.sin6_addr = nla_get_in6_addr(nla);
J
Jiri Benc 已提交
122 123 124
		ip->sa.sa_family = AF_INET6;
		return 0;
	} else if (nla_len(nla) >= sizeof(__be32)) {
125
		ip->sin.sin_addr.s_addr = nla_get_in_addr(nla);
J
Jiri Benc 已提交
126 127 128 129 130
		ip->sa.sa_family = AF_INET;
		return 0;
	} else {
		return -EAFNOSUPPORT;
	}
C
Cong Wang 已提交
131 132 133
}

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
J
Jiri Benc 已提交
134
			      const union vxlan_addr *ip)
C
Cong Wang 已提交
135
{
J
Jiri Benc 已提交
136
	if (ip->sa.sa_family == AF_INET6)
137
		return nla_put_in6_addr(skb, attr, &ip->sin6.sin6_addr);
J
Jiri Benc 已提交
138
	else
139
		return nla_put_in_addr(skb, attr, ip->sin.sin_addr.s_addr);
C
Cong Wang 已提交
140 141 142 143 144 145 146
}

#else /* !CONFIG_IPV6 */

static inline
bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
{
J
Jiri Benc 已提交
147
	return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
C
Cong Wang 已提交
148 149 150 151
}

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
{
J
Jiri Benc 已提交
152
	return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
C
Cong Wang 已提交
153 154 155 156
}

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
{
J
Jiri Benc 已提交
157
	return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
C
Cong Wang 已提交
158 159 160 161
}

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
{
J
Jiri Benc 已提交
162 163 164
	if (nla_len(nla) >= sizeof(struct in6_addr)) {
		return -EAFNOSUPPORT;
	} else if (nla_len(nla) >= sizeof(__be32)) {
165
		ip->sin.sin_addr.s_addr = nla_get_in_addr(nla);
J
Jiri Benc 已提交
166 167 168 169 170
		ip->sa.sa_family = AF_INET;
		return 0;
	} else {
		return -EAFNOSUPPORT;
	}
C
Cong Wang 已提交
171 172 173
}

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
J
Jiri Benc 已提交
174
			      const union vxlan_addr *ip)
C
Cong Wang 已提交
175
{
176
	return nla_put_in_addr(skb, attr, ip->sin.sin_addr.s_addr);
C
Cong Wang 已提交
177 178 179
}
#endif

180
/* Virtual Network hash table head */
181
static inline struct hlist_head *vni_head(struct vxlan_sock *vs, __be32 vni)
182
{
183
	return &vs->vni_list[hash_32((__force u32)vni, VNI_HASH_BITS)];
184 185 186 187
}

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

191 192 193
	return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
}

194 195 196
/* First remote destination for a forwarding entry.
 * Guaranteed to be non-NULL because remotes are never deleted.
 */
197
static inline struct vxlan_rdst *first_remote_rcu(struct vxlan_fdb *fdb)
198
{
199 200 201 202 203 204
	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);
205 206
}

207 208 209 210 211
/* 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)
212 213
{
	struct vxlan_sock *vs;
214 215

	flags &= VXLAN_F_RCV_FLAGS;
216 217

	hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {
218
		if (inet_sk(vs->sock->sk)->inet_sport == port &&
219
		    vxlan_get_sk_family(vs) == family &&
220
		    vs->flags == flags)
221 222 223
			return vs;
	}
	return NULL;
S
stephen hemminger 已提交
224 225
}

226
static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs, __be32 vni)
S
stephen hemminger 已提交
227 228 229
{
	struct vxlan_dev *vxlan;

230 231 232 233
	/* For flow based devices, map all packets to VNI 0 */
	if (vs->flags & VXLAN_F_COLLECT_METADATA)
		vni = 0;

234 235
	hlist_for_each_entry_rcu(vxlan, vni_head(vs, vni), hlist) {
		if (vxlan->default_dst.remote_vni == vni)
S
stephen hemminger 已提交
236 237 238 239 240 241
			return vxlan;
	}

	return NULL;
}

P
Pravin B Shelar 已提交
242
/* Look up VNI in a per net namespace table */
243
static struct vxlan_dev *vxlan_find_vni(struct net *net, __be32 vni,
244 245
					sa_family_t family, __be16 port,
					u32 flags)
P
Pravin B Shelar 已提交
246 247 248
{
	struct vxlan_sock *vs;

249
	vs = vxlan_find_sock(net, family, port, flags);
P
Pravin B Shelar 已提交
250 251 252
	if (!vs)
		return NULL;

253
	return vxlan_vs_find_vni(vs, vni);
P
Pravin B Shelar 已提交
254 255
}

S
stephen hemminger 已提交
256 257
/* Fill in neighbour message in skbuff. */
static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,
S
Stephen Hemminger 已提交
258 259 260
			  const struct vxlan_fdb *fdb,
			  u32 portid, u32 seq, int type, unsigned int flags,
			  const struct vxlan_rdst *rdst)
S
stephen hemminger 已提交
261 262 263 264 265
{
	unsigned long now = jiffies;
	struct nda_cacheinfo ci;
	struct nlmsghdr *nlh;
	struct ndmsg *ndm;
D
David Stevens 已提交
266
	bool send_ip, send_eth;
S
stephen hemminger 已提交
267 268 269 270 271 272 273

	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 已提交
274 275 276 277 278

	send_eth = send_ip = true;

	if (type == RTM_GETNEIGH) {
		ndm->ndm_family	= AF_INET;
C
Cong Wang 已提交
279
		send_ip = !vxlan_addr_any(&rdst->remote_ip);
D
David Stevens 已提交
280 281 282
		send_eth = !is_zero_ether_addr(fdb->eth_addr);
	} else
		ndm->ndm_family	= AF_BRIDGE;
S
stephen hemminger 已提交
283 284
	ndm->ndm_state = fdb->state;
	ndm->ndm_ifindex = vxlan->dev->ifindex;
285
	ndm->ndm_flags = fdb->flags;
286
	ndm->ndm_type = RTN_UNICAST;
S
stephen hemminger 已提交
287

288
	if (!net_eq(dev_net(vxlan->dev), vxlan->net) &&
289
	    nla_put_s32(skb, NDA_LINK_NETNSID,
290
			peernet2id(dev_net(vxlan->dev), vxlan->net)))
291 292
		goto nla_put_failure;

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

C
Cong Wang 已提交
296
	if (send_ip && vxlan_nla_put_addr(skb, NDA_DST, &rdst->remote_ip))
297 298
		goto nla_put_failure;

299
	if (rdst->remote_port && rdst->remote_port != vxlan->cfg.dst_port &&
300 301
	    nla_put_be16(skb, NDA_PORT, rdst->remote_port))
		goto nla_put_failure;
302
	if (rdst->remote_vni != vxlan->default_dst.remote_vni &&
303
	    nla_put_u32(skb, NDA_VNI, be32_to_cpu(rdst->remote_vni)))
304 305 306
		goto nla_put_failure;
	if (rdst->remote_ifindex &&
	    nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
S
stephen hemminger 已提交
307 308 309 310 311 312 313 314 315 316
		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;

317 318
	nlmsg_end(skb, nlh);
	return 0;
S
stephen hemminger 已提交
319 320 321 322 323 324 325 326 327 328

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 已提交
329
		+ nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */
330
		+ nla_total_size(sizeof(__be16)) /* NDA_PORT */
331 332
		+ nla_total_size(sizeof(__be32)) /* NDA_VNI */
		+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
333
		+ nla_total_size(sizeof(__s32)) /* NDA_LINK_NETNSID */
S
stephen hemminger 已提交
334 335 336
		+ nla_total_size(sizeof(struct nda_cacheinfo));
}

337 338
static void vxlan_fdb_notify(struct vxlan_dev *vxlan, struct vxlan_fdb *fdb,
			     struct vxlan_rdst *rd, int type)
S
stephen hemminger 已提交
339 340 341 342 343 344 345 346 347
{
	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;

348
	err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0, rd);
S
stephen hemminger 已提交
349 350 351 352 353 354 355 356 357 358 359 360 361 362
	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 已提交
363
static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)
D
David Stevens 已提交
364 365
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
366 367 368 369
	struct vxlan_fdb f = {
		.state = NUD_STALE,
	};
	struct vxlan_rdst remote = {
C
Cong Wang 已提交
370
		.remote_ip = *ipa, /* goes to NDA_DST */
371
		.remote_vni = cpu_to_be32(VXLAN_N_VID),
372
	};
373

374
	vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH);
D
David Stevens 已提交
375 376 377 378
}

static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])
{
379 380 381
	struct vxlan_fdb f = {
		.state = NUD_STALE,
	};
382
	struct vxlan_rdst remote = { };
D
David Stevens 已提交
383 384 385

	memcpy(f.eth_addr, eth_addr, ETH_ALEN);

386
	vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH);
D
David Stevens 已提交
387 388
}

S
stephen hemminger 已提交
389 390 391 392 393 394 395 396
/* 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;
397 398
#else
	value <<= 16;
S
stephen hemminger 已提交
399 400 401 402 403 404 405 406 407 408 409 410
#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 */
411
static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,
S
stephen hemminger 已提交
412 413 414 415 416
					const u8 *mac)
{
	struct hlist_head *head = vxlan_fdb_head(vxlan, mac);
	struct vxlan_fdb *f;

417
	hlist_for_each_entry_rcu(f, head, hlist) {
418
		if (ether_addr_equal(mac, f->eth_addr))
S
stephen hemminger 已提交
419 420 421 422 423 424
			return f;
	}

	return NULL;
}

425 426 427 428 429 430 431 432 433 434 435 436
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;
}

437 438
/* caller should hold vxlan->hash_lock */
static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,
C
Cong Wang 已提交
439
					      union vxlan_addr *ip, __be16 port,
440
					      __be32 vni, __u32 ifindex)
441
{
442
	struct vxlan_rdst *rd;
443

444
	list_for_each_entry(rd, &f->remotes, list) {
C
Cong Wang 已提交
445
		if (vxlan_addr_equal(&rd->remote_ip, ip) &&
446 447 448
		    rd->remote_port == port &&
		    rd->remote_vni == vni &&
		    rd->remote_ifindex == ifindex)
449
			return rd;
450
	}
451

452 453 454
	return NULL;
}

455 456
/* Replace destination of unicast mac */
static int vxlan_fdb_replace(struct vxlan_fdb *f,
457 458
			     union vxlan_addr *ip, __be16 port, __be32 vni,
			     __u32 ifindex)
459 460 461 462 463 464 465 466 467 468
{
	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;
469 470

	dst_cache_reset(&rd->dst_cache);
C
Cong Wang 已提交
471
	rd->remote_ip = *ip;
472 473 474 475 476 477
	rd->remote_port = port;
	rd->remote_vni = vni;
	rd->remote_ifindex = ifindex;
	return 1;
}

478 479
/* Add/update destinations for multicast */
static int vxlan_fdb_append(struct vxlan_fdb *f,
480
			    union vxlan_addr *ip, __be16 port, __be32 vni,
481
			    __u32 ifindex, struct vxlan_rdst **rdp)
482 483 484 485 486 487 488
{
	struct vxlan_rdst *rd;

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

489 490 491
	rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
	if (rd == NULL)
		return -ENOBUFS;
492 493 494 495 496 497

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

C
Cong Wang 已提交
498
	rd->remote_ip = *ip;
499 500 501
	rd->remote_port = port;
	rd->remote_vni = vni;
	rd->remote_ifindex = ifindex;
502 503 504

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

505
	*rdp = rd;
506 507 508
	return 1;
}

T
Tom Herbert 已提交
509 510 511
static struct vxlanhdr *vxlan_gro_remcsum(struct sk_buff *skb,
					  unsigned int off,
					  struct vxlanhdr *vh, size_t hdrlen,
512 513
					  __be32 vni_field,
					  struct gro_remcsum *grc,
514
					  bool nopartial)
T
Tom Herbert 已提交
515
{
516
	size_t start, offset;
T
Tom Herbert 已提交
517 518

	if (skb->remcsum_offload)
519
		return vh;
T
Tom Herbert 已提交
520 521 522 523

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

524 525
	start = vxlan_rco_start(vni_field);
	offset = start + vxlan_rco_offset(vni_field);
T
Tom Herbert 已提交
526

527 528
	vh = skb_gro_remcsum_process(skb, (void *)vh, off, hdrlen,
				     start, offset, grc, nopartial);
T
Tom Herbert 已提交
529 530 531 532 533 534

	skb->remcsum_offload = 1;

	return vh;
}

535 536 537
static struct sk_buff **vxlan_gro_receive(struct sock *sk,
					  struct sk_buff **head,
					  struct sk_buff *skb)
538 539 540
{
	struct sk_buff *p, **pp = NULL;
	struct vxlanhdr *vh, *vh2;
541
	unsigned int hlen, off_vx;
542
	int flush = 1;
543
	struct vxlan_sock *vs = rcu_dereference_sk_user_data(sk);
544
	__be32 flags;
545 546 547
	struct gro_remcsum grc;

	skb_gro_remcsum_init(&grc);
548 549 550 551 552 553 554 555 556 557

	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 已提交
558 559
	skb_gro_postpull_rcsum(skb, vh, sizeof(struct vxlanhdr));

560
	flags = vh->vx_flags;
T
Tom Herbert 已提交
561 562 563

	if ((flags & VXLAN_HF_RCO) && (vs->flags & VXLAN_F_REMCSUM_RX)) {
		vh = vxlan_gro_remcsum(skb, off_vx, vh, sizeof(struct vxlanhdr),
564
				       vh->vx_vni, &grc,
565 566
				       !!(vs->flags &
					  VXLAN_F_REMCSUM_NOPARTIAL));
T
Tom Herbert 已提交
567 568 569 570 571

		if (!vh)
			goto out;
	}

572 573
	skb_gro_pull(skb, sizeof(struct vxlanhdr)); /* pull vxlan header */

574 575 576 577 578
	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 已提交
579 580
		if (vh->vx_flags != vh2->vx_flags ||
		    vh->vx_vni != vh2->vx_vni) {
581 582 583 584 585
			NAPI_GRO_CB(p)->same_flow = 0;
			continue;
		}
	}

S
Sabrina Dubroca 已提交
586
	pp = call_gro_receive(eth_gro_receive, head, skb);
587
	flush = 0;
588 589

out:
590
	skb_gro_remcsum_cleanup(skb, &grc);
591 592 593 594 595
	NAPI_GRO_CB(skb)->flush |= flush;

	return pp;
}

596
static int vxlan_gro_complete(struct sock *sk, struct sk_buff *skb, int nhoff)
597
{
598 599 600
	/* Sets 'skb->inner_mac_header' since we are always called with
	 * 'skb->encapsulation' set.
	 */
601
	return eth_gro_complete(skb, nhoff + sizeof(struct vxlanhdr));
602 603
}

S
stephen hemminger 已提交
604 605
/* Add new entry to forwarding table -- assumes lock held */
static int vxlan_fdb_create(struct vxlan_dev *vxlan,
C
Cong Wang 已提交
606
			    const u8 *mac, union vxlan_addr *ip,
607
			    __u16 state, __u16 flags,
608
			    __be16 port, __be32 vni, __u32 ifindex,
609
			    __u8 ndm_flags)
S
stephen hemminger 已提交
610
{
611
	struct vxlan_rdst *rd = NULL;
S
stephen hemminger 已提交
612 613
	struct vxlan_fdb *f;
	int notify = 0;
614
	int rc;
S
stephen hemminger 已提交
615

616
	f = __vxlan_find_mac(vxlan, mac);
S
stephen hemminger 已提交
617 618 619 620 621 622 623 624 625 626 627
	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;
		}
628 629 630 631 632
		if (f->flags != ndm_flags) {
			f->flags = ndm_flags;
			f->updated = jiffies;
			notify = 1;
		}
633 634 635 636
		if ((flags & NLM_F_REPLACE)) {
			/* Only change unicasts */
			if (!(is_multicast_ether_addr(f->eth_addr) ||
			     is_zero_ether_addr(f->eth_addr))) {
637
				notify |= vxlan_fdb_replace(f, ip, port, vni,
638 639 640 641
							   ifindex);
			} else
				return -EOPNOTSUPP;
		}
642
		if ((flags & NLM_F_APPEND) &&
643 644
		    (is_multicast_ether_addr(f->eth_addr) ||
		     is_zero_ether_addr(f->eth_addr))) {
645
			rc = vxlan_fdb_append(f, ip, port, vni, ifindex, &rd);
646 647 648 649 650

			if (rc < 0)
				return rc;
			notify |= rc;
		}
S
stephen hemminger 已提交
651 652 653 654
	} else {
		if (!(flags & NLM_F_CREATE))
			return -ENOENT;

655 656
		if (vxlan->cfg.addrmax &&
		    vxlan->addrcnt >= vxlan->cfg.addrmax)
S
stephen hemminger 已提交
657 658
			return -ENOSPC;

659 660 661 662 663
		/* 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 已提交
664
		netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);
S
stephen hemminger 已提交
665 666 667 668 669 670
		f = kmalloc(sizeof(*f), GFP_ATOMIC);
		if (!f)
			return -ENOMEM;

		notify = 1;
		f->state = state;
671
		f->flags = ndm_flags;
S
stephen hemminger 已提交
672
		f->updated = f->used = jiffies;
673
		INIT_LIST_HEAD(&f->remotes);
S
stephen hemminger 已提交
674 675
		memcpy(f->eth_addr, mac, ETH_ALEN);

676 677 678 679 680
		rc = vxlan_fdb_append(f, ip, port, vni, ifindex, &rd);
		if (rc < 0) {
			kfree(f);
			return rc;
		}
681

S
stephen hemminger 已提交
682 683 684 685 686
		++vxlan->addrcnt;
		hlist_add_head_rcu(&f->hlist,
				   vxlan_fdb_head(vxlan, mac));
	}

687 688 689 690 691
	if (notify) {
		if (rd == NULL)
			rd = first_remote_rtnl(f);
		vxlan_fdb_notify(vxlan, f, rd, RTM_NEWNEIGH);
	}
S
stephen hemminger 已提交
692 693 694 695

	return 0;
}

W
Wei Yongjun 已提交
696
static void vxlan_fdb_free(struct rcu_head *head)
697 698
{
	struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);
699
	struct vxlan_rdst *rd, *nd;
700

701 702
	list_for_each_entry_safe(rd, nd, &f->remotes, list) {
		dst_cache_destroy(&rd->dst_cache);
703
		kfree(rd);
704
	}
705 706 707
	kfree(f);
}

S
stephen hemminger 已提交
708 709 710 711 712 713
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;
714
	vxlan_fdb_notify(vxlan, f, first_remote_rtnl(f), RTM_DELNEIGH);
S
stephen hemminger 已提交
715 716

	hlist_del_rcu(&f->hlist);
717
	call_rcu(&f->rcu, vxlan_fdb_free);
S
stephen hemminger 已提交
718 719
}

M
Mike Rapoport 已提交
720
static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,
721 722
			   union vxlan_addr *ip, __be16 *port, __be32 *vni,
			   u32 *ifindex)
S
stephen hemminger 已提交
723
{
724
	struct net *net = dev_net(vxlan->dev);
C
Cong Wang 已提交
725
	int err;
S
stephen hemminger 已提交
726

M
Mike Rapoport 已提交
727
	if (tb[NDA_DST]) {
C
Cong Wang 已提交
728 729 730
		err = vxlan_nla_get_addr(ip, tb[NDA_DST]);
		if (err)
			return err;
M
Mike Rapoport 已提交
731
	} else {
C
Cong Wang 已提交
732 733 734 735 736 737 738 739 740 741
		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 已提交
742
	}
S
stephen hemminger 已提交
743

744
	if (tb[NDA_PORT]) {
745
		if (nla_len(tb[NDA_PORT]) != sizeof(__be16))
746
			return -EINVAL;
M
Mike Rapoport 已提交
747 748
		*port = nla_get_be16(tb[NDA_PORT]);
	} else {
749
		*port = vxlan->cfg.dst_port;
M
Mike Rapoport 已提交
750
	}
751 752 753 754

	if (tb[NDA_VNI]) {
		if (nla_len(tb[NDA_VNI]) != sizeof(u32))
			return -EINVAL;
755
		*vni = cpu_to_be32(nla_get_u32(tb[NDA_VNI]));
M
Mike Rapoport 已提交
756 757 758
	} else {
		*vni = vxlan->default_dst.remote_vni;
	}
759 760

	if (tb[NDA_IFINDEX]) {
P
Pravin B Shelar 已提交
761
		struct net_device *tdev;
762 763 764

		if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
			return -EINVAL;
M
Mike Rapoport 已提交
765
		*ifindex = nla_get_u32(tb[NDA_IFINDEX]);
766
		tdev = __dev_get_by_index(net, *ifindex);
P
Pravin B Shelar 已提交
767
		if (!tdev)
768
			return -EADDRNOTAVAIL;
M
Mike Rapoport 已提交
769 770 771 772 773 774 775 776 777 778
	} 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,
779
			 const unsigned char *addr, u16 vid, u16 flags)
M
Mike Rapoport 已提交
780 781 782
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	/* struct net *net = dev_net(vxlan->dev); */
C
Cong Wang 已提交
783
	union vxlan_addr ip;
M
Mike Rapoport 已提交
784
	__be16 port;
785 786
	__be32 vni;
	u32 ifindex;
M
Mike Rapoport 已提交
787 788 789 790 791 792 793 794 795 796 797 798 799 800
	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;
801

802 803 804
	if (vxlan->default_dst.remote_ip.sa.sa_family != ip.sa.sa_family)
		return -EAFNOSUPPORT;

S
stephen hemminger 已提交
805
	spin_lock_bh(&vxlan->hash_lock);
C
Cong Wang 已提交
806
	err = vxlan_fdb_create(vxlan, addr, &ip, ndm->ndm_state, flags,
807
			       port, vni, ifindex, ndm->ndm_flags);
S
stephen hemminger 已提交
808 809 810 811 812 813
	spin_unlock_bh(&vxlan->hash_lock);

	return err;
}

/* Delete entry (via netlink) */
814 815
static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
			    struct net_device *dev,
816
			    const unsigned char *addr, u16 vid)
S
stephen hemminger 已提交
817 818 819
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb *f;
820
	struct vxlan_rdst *rd = NULL;
C
Cong Wang 已提交
821
	union vxlan_addr ip;
822
	__be16 port;
823 824
	__be32 vni;
	u32 ifindex;
825 826 827 828 829 830 831
	int err;

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

	err = -ENOENT;
S
stephen hemminger 已提交
832 833 834

	spin_lock_bh(&vxlan->hash_lock);
	f = vxlan_find_mac(vxlan, addr);
835 836 837
	if (!f)
		goto out;

C
Cong Wang 已提交
838 839
	if (!vxlan_addr_any(&ip)) {
		rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);
840 841 842 843 844 845 846 847 848 849 850
		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);
851
		vxlan_fdb_notify(vxlan, f, rd, RTM_DELNEIGH);
852
		kfree_rcu(rd, rcu);
853
		goto out;
S
stephen hemminger 已提交
854
	}
855 856 857 858

	vxlan_fdb_destroy(vxlan, f);

out:
S
stephen hemminger 已提交
859 860 861 862 863 864 865
	spin_unlock_bh(&vxlan->hash_lock);

	return err;
}

/* Dump forwarding table */
static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
866
			  struct net_device *dev,
867
			  struct net_device *filter_dev, int *idx)
S
stephen hemminger 已提交
868 869 870
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	unsigned int h;
871
	int err = 0;
S
stephen hemminger 已提交
872 873 874 875

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

876
		hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
877 878
			struct vxlan_rdst *rd;

879
			list_for_each_entry_rcu(rd, &f->remotes, list) {
880
				if (*idx < cb->args[2])
881 882
					goto skip;

883 884 885 886 887
				err = vxlan_fdb_info(skb, vxlan, f,
						     NETLINK_CB(cb->skb).portid,
						     cb->nlh->nlmsg_seq,
						     RTM_NEWNEIGH,
						     NLM_F_MULTI, rd);
888
				if (err < 0)
889 890
					goto out;
skip:
891
				*idx += 1;
892
			}
S
stephen hemminger 已提交
893 894
		}
	}
895
out:
896
	return err;
S
stephen hemminger 已提交
897 898 899 900
}

/* Watch incoming packets to learn mapping between Ethernet address
 * and Tunnel endpoint.
901
 * Return true if packet is bogus and should be dropped.
S
stephen hemminger 已提交
902
 */
903
static bool vxlan_snoop(struct net_device *dev,
C
Cong Wang 已提交
904
			union vxlan_addr *src_ip, const u8 *src_mac)
S
stephen hemminger 已提交
905 906 907 908 909 910
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb *f;

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

C
Cong Wang 已提交
913
		if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip)))
914 915 916
			return false;

		/* Don't migrate static entries, drop packets */
917
		if (f->state & NUD_NOARP)
918
			return true;
S
stephen hemminger 已提交
919 920 921

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

C
Cong Wang 已提交
925
		rdst->remote_ip = *src_ip;
S
stephen hemminger 已提交
926
		f->updated = jiffies;
927
		vxlan_fdb_notify(vxlan, f, rdst, RTM_NEWNEIGH);
S
stephen hemminger 已提交
928 929 930
	} else {
		/* learned new entry */
		spin_lock(&vxlan->hash_lock);
931 932 933 934 935 936

		/* 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,
937
					 vxlan->cfg.dst_port,
938 939
					 vxlan->default_dst.remote_vni,
					 0, NTF_SELF);
S
stephen hemminger 已提交
940 941
		spin_unlock(&vxlan->hash_lock);
	}
942 943

	return false;
S
stephen hemminger 已提交
944 945 946
}

/* See if multicast group is already in use by other ID */
947
static bool vxlan_group_used(struct vxlan_net *vn, struct vxlan_dev *dev)
S
stephen hemminger 已提交
948
{
949
	struct vxlan_dev *vxlan;
950
	struct vxlan_sock *sock4;
A
Arnd Bergmann 已提交
951 952 953
#if IS_ENABLED(CONFIG_IPV6)
	struct vxlan_sock *sock6;
#endif
954
	unsigned short family = dev->default_dst.remote_ip.sa.sa_family;
S
stephen hemminger 已提交
955

956 957
	sock4 = rtnl_dereference(dev->vn4_sock);

958 959 960
	/* The vxlan_sock is only used by dev, leaving group has
	 * no effect on other vxlan devices.
	 */
961
	if (family == AF_INET && sock4 && atomic_read(&sock4->refcnt) == 1)
962
		return false;
963
#if IS_ENABLED(CONFIG_IPV6)
964 965
	sock6 = rtnl_dereference(dev->vn6_sock);
	if (family == AF_INET6 && sock6 && atomic_read(&sock6->refcnt) == 1)
966 967
		return false;
#endif
968

969
	list_for_each_entry(vxlan, &vn->vxlan_list, next) {
970
		if (!netif_running(vxlan->dev) || vxlan == dev)
971
			continue;
S
stephen hemminger 已提交
972

973 974
		if (family == AF_INET &&
		    rtnl_dereference(vxlan->vn4_sock) != sock4)
975
			continue;
976
#if IS_ENABLED(CONFIG_IPV6)
977 978
		if (family == AF_INET6 &&
		    rtnl_dereference(vxlan->vn6_sock) != sock6)
979 980
			continue;
#endif
981 982 983 984 985 986 987 988 989 990

		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;
991
	}
S
stephen hemminger 已提交
992 993 994 995

	return false;
}

996
static bool __vxlan_sock_release_prep(struct vxlan_sock *vs)
997
{
998
	struct vxlan_net *vn;
999

1000
	if (!vs)
1001
		return false;
1002
	if (!atomic_dec_and_test(&vs->refcnt))
1003
		return false;
S
stephen hemminger 已提交
1004

1005
	vn = net_generic(sock_net(vs->sock->sk), vxlan_net_id);
1006
	spin_lock(&vn->sock_lock);
1007
	hlist_del_rcu(&vs->hlist);
1008
	udp_tunnel_notify_del_rx_port(vs->sock,
1009 1010
				      (vs->flags & VXLAN_F_GPE) ?
				      UDP_TUNNEL_TYPE_VXLAN_GPE :
1011
				      UDP_TUNNEL_TYPE_VXLAN);
1012 1013
	spin_unlock(&vn->sock_lock);

1014
	return true;
S
stephen hemminger 已提交
1015 1016
}

1017 1018
static void vxlan_sock_release(struct vxlan_dev *vxlan)
{
1019
	struct vxlan_sock *sock4 = rtnl_dereference(vxlan->vn4_sock);
1020
#if IS_ENABLED(CONFIG_IPV6)
1021 1022 1023
	struct vxlan_sock *sock6 = rtnl_dereference(vxlan->vn6_sock);

	rcu_assign_pointer(vxlan->vn6_sock, NULL);
1024 1025
#endif

1026
	rcu_assign_pointer(vxlan->vn4_sock, NULL);
1027 1028
	synchronize_net();

1029 1030 1031
	if (__vxlan_sock_release_prep(sock4)) {
		udp_tunnel_sock_release(sock4->sock);
		kfree(sock4);
1032 1033 1034
	}

#if IS_ENABLED(CONFIG_IPV6)
1035 1036 1037
	if (__vxlan_sock_release_prep(sock6)) {
		udp_tunnel_sock_release(sock6->sock);
		kfree(sock6);
1038
	}
1039 1040 1041
#endif
}

1042
/* Update multicast group membership when first VNI on
1043
 * multicast address is brought up
1044
 */
1045
static int vxlan_igmp_join(struct vxlan_dev *vxlan)
S
stephen hemminger 已提交
1046
{
1047
	struct sock *sk;
C
Cong Wang 已提交
1048 1049
	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
	int ifindex = vxlan->default_dst.remote_ifindex;
1050
	int ret = -EINVAL;
S
stephen hemminger 已提交
1051

C
Cong Wang 已提交
1052
	if (ip->sa.sa_family == AF_INET) {
1053
		struct vxlan_sock *sock4 = rtnl_dereference(vxlan->vn4_sock);
C
Cong Wang 已提交
1054 1055 1056 1057 1058
		struct ip_mreqn mreq = {
			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
			.imr_ifindex		= ifindex,
		};

1059
		sk = sock4->sock->sk;
1060
		lock_sock(sk);
1061
		ret = ip_mc_join_group(sk, &mreq);
1062
		release_sock(sk);
C
Cong Wang 已提交
1063 1064
#if IS_ENABLED(CONFIG_IPV6)
	} else {
1065 1066 1067
		struct vxlan_sock *sock6 = rtnl_dereference(vxlan->vn6_sock);

		sk = sock6->sock->sk;
1068
		lock_sock(sk);
1069 1070
		ret = ipv6_stub->ipv6_sock_mc_join(sk, ifindex,
						   &ip->sin6.sin6_addr);
1071
		release_sock(sk);
C
Cong Wang 已提交
1072 1073
#endif
	}
S
stephen hemminger 已提交
1074

1075
	return ret;
S
stephen hemminger 已提交
1076 1077 1078
}

/* Inverse of vxlan_igmp_join when last VNI is brought down */
1079
static int vxlan_igmp_leave(struct vxlan_dev *vxlan)
S
stephen hemminger 已提交
1080
{
1081
	struct sock *sk;
C
Cong Wang 已提交
1082 1083
	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
	int ifindex = vxlan->default_dst.remote_ifindex;
1084
	int ret = -EINVAL;
S
stephen hemminger 已提交
1085

C
Cong Wang 已提交
1086
	if (ip->sa.sa_family == AF_INET) {
1087
		struct vxlan_sock *sock4 = rtnl_dereference(vxlan->vn4_sock);
C
Cong Wang 已提交
1088 1089 1090 1091 1092
		struct ip_mreqn mreq = {
			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
			.imr_ifindex		= ifindex,
		};

1093
		sk = sock4->sock->sk;
1094
		lock_sock(sk);
1095
		ret = ip_mc_leave_group(sk, &mreq);
1096
		release_sock(sk);
C
Cong Wang 已提交
1097 1098
#if IS_ENABLED(CONFIG_IPV6)
	} else {
1099 1100 1101
		struct vxlan_sock *sock6 = rtnl_dereference(vxlan->vn6_sock);

		sk = sock6->sock->sk;
1102
		lock_sock(sk);
1103 1104
		ret = ipv6_stub->ipv6_sock_mc_drop(sk, ifindex,
						   &ip->sin6.sin6_addr);
1105
		release_sock(sk);
C
Cong Wang 已提交
1106 1107
#endif
	}
S
stephen hemminger 已提交
1108

1109
	return ret;
S
stephen hemminger 已提交
1110 1111
}

1112 1113
static bool vxlan_remcsum(struct vxlanhdr *unparsed,
			  struct sk_buff *skb, u32 vxflags)
T
Tom Herbert 已提交
1114
{
1115
	size_t start, offset;
T
Tom Herbert 已提交
1116

1117 1118
	if (!(unparsed->vx_flags & VXLAN_HF_RCO) || skb->remcsum_offload)
		goto out;
1119

1120 1121
	start = vxlan_rco_start(unparsed->vx_vni);
	offset = start + vxlan_rco_offset(unparsed->vx_vni);
T
Tom Herbert 已提交
1122

1123
	if (!pskb_may_pull(skb, offset + sizeof(u16)))
J
Jiri Benc 已提交
1124
		return false;
T
Tom Herbert 已提交
1125

J
Jiri Benc 已提交
1126 1127
	skb_remcsum_process(skb, (void *)(vxlan_hdr(skb) + 1), start, offset,
			    !!(vxflags & VXLAN_F_REMCSUM_NOPARTIAL));
1128 1129 1130
out:
	unparsed->vx_flags &= ~VXLAN_HF_RCO;
	unparsed->vx_vni &= VXLAN_VNI_MASK;
J
Jiri Benc 已提交
1131
	return true;
T
Tom Herbert 已提交
1132 1133
}

1134
static void vxlan_parse_gbp_hdr(struct vxlanhdr *unparsed,
1135
				struct sk_buff *skb, u32 vxflags,
1136
				struct vxlan_metadata *md)
1137
{
1138
	struct vxlanhdr_gbp *gbp = (struct vxlanhdr_gbp *)unparsed;
1139
	struct metadata_dst *tun_dst;
1140 1141 1142

	if (!(unparsed->vx_flags & VXLAN_HF_GBP))
		goto out;
1143 1144 1145

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

1146
	tun_dst = (struct metadata_dst *)skb_dst(skb);
1147
	if (tun_dst) {
1148
		tun_dst->u.tun_info.key.tun_flags |= TUNNEL_VXLAN_OPT;
1149 1150
		tun_dst->u.tun_info.options_len = sizeof(*md);
	}
1151 1152 1153 1154 1155
	if (gbp->dont_learn)
		md->gbp |= VXLAN_GBP_DONT_LEARN;

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

1157 1158 1159
	/* In flow-based mode, GBP is carried in dst_metadata */
	if (!(vxflags & VXLAN_F_COLLECT_METADATA))
		skb->mark = md->gbp;
1160 1161
out:
	unparsed->vx_flags &= ~VXLAN_GBP_USED_BITS;
1162 1163
}

J
Jiri Benc 已提交
1164
static bool vxlan_parse_gpe_hdr(struct vxlanhdr *unparsed,
J
Jiri Benc 已提交
1165
				__be16 *protocol,
J
Jiri Benc 已提交
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
				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;
}

1203 1204 1205
static bool vxlan_set_mac(struct vxlan_dev *vxlan,
			  struct vxlan_sock *vs,
			  struct sk_buff *skb)
1206 1207 1208 1209 1210 1211 1212 1213 1214
{
	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))
1215
		return false;
1216

1217
	/* Get address from the outer IP header */
1218
	if (vxlan_get_sk_family(vs) == AF_INET) {
1219
		saddr.sin.sin_addr.s_addr = ip_hdr(skb)->saddr;
1220 1221 1222
		saddr.sa.sa_family = AF_INET;
#if IS_ENABLED(CONFIG_IPV6)
	} else {
1223
		saddr.sin6.sin6_addr = ipv6_hdr(skb)->saddr;
1224 1225 1226 1227
		saddr.sa.sa_family = AF_INET6;
#endif
	}

1228 1229 1230 1231 1232 1233 1234
	if ((vxlan->flags & VXLAN_F_LEARN) &&
	    vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source))
		return false;

	return true;
}

1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
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 已提交
1259
/* Callback from net/ipv4/udp.c to receive packets */
1260
static int vxlan_rcv(struct sock *sk, struct sk_buff *skb)
S
stephen hemminger 已提交
1261
{
1262
	struct pcpu_sw_netstats *stats;
1263
	struct vxlan_dev *vxlan;
P
Pravin B Shelar 已提交
1264
	struct vxlan_sock *vs;
1265
	struct vxlanhdr unparsed;
T
Thomas Graf 已提交
1266 1267
	struct vxlan_metadata _md;
	struct vxlan_metadata *md = &_md;
J
Jiri Benc 已提交
1268
	__be16 protocol = htons(ETH_P_TEB);
J
Jiri Benc 已提交
1269
	bool raw_proto = false;
1270
	void *oiph;
S
stephen hemminger 已提交
1271

J
Jiri Benc 已提交
1272
	/* Need UDP and VXLAN header to be present */
1273
	if (!pskb_may_pull(skb, VXLAN_HLEN))
1274
		goto drop;
S
stephen hemminger 已提交
1275

1276
	unparsed = *vxlan_hdr(skb);
J
Jiri Benc 已提交
1277 1278 1279 1280 1281 1282
	/* 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 */
1283
		goto drop;
S
stephen hemminger 已提交
1284
	}
J
Jiri Benc 已提交
1285 1286
	unparsed.vx_flags &= ~VXLAN_HF_VNI;
	unparsed.vx_vni &= ~VXLAN_VNI_MASK;
S
stephen hemminger 已提交
1287

1288
	vs = rcu_dereference_sk_user_data(sk);
P
Pravin B Shelar 已提交
1289
	if (!vs)
S
stephen hemminger 已提交
1290 1291
		goto drop;

1292 1293 1294 1295
	vxlan = vxlan_vs_find_vni(vs, vxlan_vni(vxlan_hdr(skb)->vx_vni));
	if (!vxlan)
		goto drop;

J
Jiri Benc 已提交
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
	/* 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;
1308

T
Thomas Graf 已提交
1309
	if (vxlan_collect_metadata(vs)) {
J
Jiri Benc 已提交
1310
		__be32 vni = vxlan_vni(vxlan_hdr(skb)->vx_vni);
1311
		struct metadata_dst *tun_dst;
J
Jiri Benc 已提交
1312

1313
		tun_dst = udp_tun_rx_dst(skb, vxlan_get_sk_family(vs), TUNNEL_KEY,
1314
					 key32_to_tunnel_id(vni), sizeof(*md));
1315

T
Thomas Graf 已提交
1316 1317 1318
		if (!tun_dst)
			goto drop;

1319
		md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
1320 1321

		skb_dst_set(skb, (struct dst_entry *)tun_dst);
T
Thomas Graf 已提交
1322 1323 1324 1325
	} else {
		memset(md, 0, sizeof(*md));
	}

1326 1327 1328 1329
	if (vs->flags & VXLAN_F_REMCSUM_RX)
		if (!vxlan_remcsum(&unparsed, skb, vs->flags))
			goto drop;
	if (vs->flags & VXLAN_F_GBP)
1330
		vxlan_parse_gbp_hdr(&unparsed, skb, vs->flags, md);
J
Jiri Benc 已提交
1331 1332 1333
	/* Note that GBP and GPE can never be active together. This is
	 * ensured in vxlan_dev_configure.
	 */
T
Thomas Graf 已提交
1334

1335
	if (unparsed.vx_flags || unparsed.vx_vni) {
1336 1337 1338 1339
		/* 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
1340
		 * maintains compatibility with previous stack code, and also
1341 1342 1343
		 * is more robust and provides a little more security in
		 * adding extensions to VXLAN.
		 */
J
Jiri Benc 已提交
1344
		goto drop;
1345 1346
	}

J
Jiri Benc 已提交
1347 1348 1349 1350
	if (!raw_proto) {
		if (!vxlan_set_mac(vxlan, vs, skb))
			goto drop;
	} else {
1351
		skb_reset_mac_header(skb);
J
Jiri Benc 已提交
1352 1353 1354
		skb->dev = vxlan->dev;
		skb->pkt_type = PACKET_HOST;
	}
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371

	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 已提交
1372 1373 1374
	return 0;

drop:
J
Jiri Benc 已提交
1375 1376 1377
	/* Consume bad packet */
	kfree_skb(skb);
	return 0;
P
Pravin B Shelar 已提交
1378 1379
}

D
David Stevens 已提交
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
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 已提交
1428
		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
D
David Stevens 已提交
1429 1430 1431 1432 1433 1434 1435 1436 1437 1438
			/* 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);

1439 1440 1441
		if (reply == NULL)
			goto out;

D
David Stevens 已提交
1442 1443 1444 1445 1446 1447 1448
		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 已提交
1449 1450 1451
	} else if (vxlan->flags & VXLAN_F_L3MISS) {
		union vxlan_addr ipa = {
			.sin.sin_addr.s_addr = tip,
1452
			.sin.sin_family = AF_INET,
C
Cong Wang 已提交
1453 1454 1455 1456
		};

		vxlan_ip_miss(dev, &ipa);
	}
D
David Stevens 已提交
1457 1458 1459 1460 1461
out:
	consume_skb(skb);
	return NETDEV_TX_OK;
}

C
Cong Wang 已提交
1462
#if IS_ENABLED(CONFIG_IPV6)
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487
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));
1488
	skb_reset_mac_header(reply);
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507

	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));
1508
	skb_reset_network_header(reply);
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
	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));
1523
	skb_reset_transport_header(reply);
1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550

	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 已提交
1551 1552 1553
static int neigh_reduce(struct net_device *dev, struct sk_buff *skb)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
1554
	struct nd_msg *msg;
C
Cong Wang 已提交
1555 1556
	const struct ipv6hdr *iphdr;
	const struct in6_addr *saddr, *daddr;
1557 1558
	struct neighbour *n;
	struct inet6_dev *in6_dev;
C
Cong Wang 已提交
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572

	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;

1573 1574 1575 1576 1577
	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 已提交
1578 1579 1580

	if (n) {
		struct vxlan_fdb *f;
1581
		struct sk_buff *reply;
C
Cong Wang 已提交
1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594

		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;
		}

1595 1596 1597
		reply = vxlan_na_create(skb, n,
					!!(f ? f->flags & NTF_ROUTER : 0));

C
Cong Wang 已提交
1598
		neigh_release(n);
1599 1600 1601 1602 1603 1604 1605

		if (reply == NULL)
			goto out;

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

C
Cong Wang 已提交
1606
	} else if (vxlan->flags & VXLAN_F_L3MISS) {
1607 1608
		union vxlan_addr ipa = {
			.sin6.sin6_addr = msg->target,
1609
			.sin6.sin6_family = AF_INET6,
1610 1611
		};

C
Cong Wang 已提交
1612 1613 1614 1615 1616 1617 1618 1619 1620
		vxlan_ip_miss(dev, &ipa);
	}

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

D
David Stevens 已提交
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631
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:
1632 1633 1634
	{
		struct iphdr *pip;

D
David Stevens 已提交
1635 1636 1637 1638
		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 已提交
1639 1640 1641
		if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
			union vxlan_addr ipa = {
				.sin.sin_addr.s_addr = pip->daddr,
1642
				.sin.sin_family = AF_INET,
C
Cong Wang 已提交
1643 1644 1645 1646 1647 1648
			};

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

D
David Stevens 已提交
1649
		break;
1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
	}
#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,
1663
				.sin6.sin6_family = AF_INET6,
1664 1665 1666 1667 1668 1669 1670 1671 1672
			};

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

		break;
	}
#endif
D
David Stevens 已提交
1673 1674 1675 1676 1677 1678 1679
	default:
		return false;
	}

	if (n) {
		bool diff;

1680
		diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);
D
David Stevens 已提交
1681 1682 1683 1684 1685 1686 1687
		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 已提交
1688 1689
	}

D
David Stevens 已提交
1690 1691 1692
	return false;
}

1693
static void vxlan_build_gbp_hdr(struct vxlanhdr *vxh, u32 vxflags,
T
Thomas Graf 已提交
1694 1695 1696 1697
				struct vxlan_metadata *md)
{
	struct vxlanhdr_gbp *gbp;

1698 1699 1700
	if (!md->gbp)
		return;

T
Thomas Graf 已提交
1701
	gbp = (struct vxlanhdr_gbp *)vxh;
1702
	vxh->vx_flags |= VXLAN_HF_GBP;
T
Thomas Graf 已提交
1703 1704 1705 1706 1707 1708 1709 1710 1711 1712

	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 已提交
1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
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;
}

1734 1735 1736
static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,
			   int iphdr_len, __be32 vni,
			   struct vxlan_metadata *md, u32 vxflags,
1737
			   bool udp_sum)
C
Cong Wang 已提交
1738 1739 1740 1741
{
	struct vxlanhdr *vxh;
	int min_headroom;
	int err;
T
Tom Herbert 已提交
1742
	int type = udp_sum ? SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
J
Jiri Benc 已提交
1743
	__be16 inner_protocol = htons(ETH_P_TEB);
T
Tom Herbert 已提交
1744

1745
	if ((vxflags & VXLAN_F_REMCSUM_TX) &&
T
Tom Herbert 已提交
1746 1747 1748 1749 1750 1751
	    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) ||
1752
		     skb->csum_offset == offsetof(struct tcphdr, check)))
T
Tom Herbert 已提交
1753 1754
			type |= SKB_GSO_TUNNEL_REMCSUM;
	}
C
Cong Wang 已提交
1755 1756

	min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len
1757
			+ VXLAN_HLEN + iphdr_len;
1758 1759 1760

	/* Need space for new headers (invalidates iph ptr) */
	err = skb_cow_head(skb, min_headroom);
J
Jiri Benc 已提交
1761
	if (unlikely(err))
P
pravin shelar 已提交
1762
		return err;
1763

1764 1765
	err = iptunnel_handle_offloads(skb, type);
	if (err)
P
pravin shelar 已提交
1766
		return err;
1767

1768
	vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
1769 1770
	vxh->vx_flags = VXLAN_HF_VNI;
	vxh->vx_vni = vxlan_vni_field(vni);
1771

T
Tom Herbert 已提交
1772
	if (type & SKB_GSO_TUNNEL_REMCSUM) {
1773
		unsigned int start;
T
Tom Herbert 已提交
1774

1775 1776 1777
		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 已提交
1778 1779 1780 1781 1782 1783 1784

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

1785 1786
	if (vxflags & VXLAN_F_GBP)
		vxlan_build_gbp_hdr(vxh, vxflags, md);
J
Jiri Benc 已提交
1787 1788 1789
	if (vxflags & VXLAN_F_GPE) {
		err = vxlan_build_gpe_hdr(vxh, vxflags, skb->protocol);
		if (err < 0)
P
pravin shelar 已提交
1790
			return err;
J
Jiri Benc 已提交
1791 1792
		inner_protocol = skb->protocol;
	}
T
Thomas Graf 已提交
1793

J
Jiri Benc 已提交
1794
	skb_set_inner_protocol(skb, inner_protocol);
1795
	return 0;
1796 1797
}

1798 1799
static struct rtable *vxlan_get_route(struct vxlan_dev *vxlan, struct net_device *dev,
				      struct vxlan_sock *sock4,
1800
				      struct sk_buff *skb, int oif, u8 tos,
1801 1802
				      __be32 daddr, __be32 *saddr,
				      struct dst_cache *dst_cache,
1803
				      const struct ip_tunnel_info *info)
1804
{
1805
	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
1806 1807 1808
	struct rtable *rt = NULL;
	struct flowi4 fl4;

1809 1810 1811
	if (!sock4)
		return ERR_PTR(-EIO);

1812 1813 1814
	if (tos && !info)
		use_cache = false;
	if (use_cache) {
1815 1816 1817 1818 1819
		rt = dst_cache_get_ip4(dst_cache, saddr);
		if (rt)
			return rt;
	}

1820 1821 1822 1823 1824 1825
	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;
1826
	fl4.saddr = *saddr;
1827 1828

	rt = ip_route_output_key(vxlan->net, &fl4);
1829 1830 1831 1832 1833 1834 1835
	if (likely(!IS_ERR(rt))) {
		if (rt->dst.dev == dev) {
			netdev_dbg(dev, "circular route to %pI4\n", &daddr);
			ip_rt_put(rt);
			return ERR_PTR(-ELOOP);
		}

1836
		*saddr = fl4.saddr;
1837 1838
		if (use_cache)
			dst_cache_set_ip4(dst_cache, &rt->dst, fl4.saddr);
1839 1840 1841
	} else {
		netdev_dbg(dev, "no route to %pI4\n", &daddr);
		return ERR_PTR(-ENETUNREACH);
1842
	}
1843 1844 1845
	return rt;
}

1846 1847
#if IS_ENABLED(CONFIG_IPV6)
static struct dst_entry *vxlan6_get_route(struct vxlan_dev *vxlan,
1848
					  struct net_device *dev,
1849
					  struct vxlan_sock *sock6,
1850
					  struct sk_buff *skb, int oif, u8 tos,
1851
					  __be32 label,
1852
					  const struct in6_addr *daddr,
1853
					  struct in6_addr *saddr,
1854 1855
					  struct dst_cache *dst_cache,
					  const struct ip_tunnel_info *info)
1856
{
1857
	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
1858 1859 1860 1861
	struct dst_entry *ndst;
	struct flowi6 fl6;
	int err;

1862 1863 1864
	if (!sock6)
		return ERR_PTR(-EIO);

1865 1866
	if (tos && !info)
		use_cache = false;
1867
	if (use_cache) {
1868 1869 1870 1871 1872
		ndst = dst_cache_get_ip6(dst_cache, saddr);
		if (ndst)
			return ndst;
	}

1873 1874 1875
	memset(&fl6, 0, sizeof(fl6));
	fl6.flowi6_oif = oif;
	fl6.daddr = *daddr;
1876
	fl6.saddr = *saddr;
1877
	fl6.flowlabel = ip6_make_flowinfo(RT_TOS(tos), label);
1878 1879 1880 1881
	fl6.flowi6_mark = skb->mark;
	fl6.flowi6_proto = IPPROTO_UDP;

	err = ipv6_stub->ipv6_dst_lookup(vxlan->net,
1882
					 sock6->sock->sk,
1883
					 &ndst, &fl6);
1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
	if (unlikely(err < 0)) {
		netdev_dbg(dev, "no route to %pI6\n", daddr);
		return ERR_PTR(-ENETUNREACH);
	}

	if (unlikely(ndst->dev == dev)) {
		netdev_dbg(dev, "circular route to %pI6\n", daddr);
		dst_release(ndst);
		return ERR_PTR(-ELOOP);
	}
1894 1895

	*saddr = fl6.saddr;
1896
	if (use_cache)
1897
		dst_cache_set_ip6(dst_cache, ndst, saddr);
1898 1899 1900 1901
	return ndst;
}
#endif

1902 1903 1904 1905
/* 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)
{
1906
	struct pcpu_sw_netstats *tx_stats, *rx_stats;
C
Cong Wang 已提交
1907 1908
	union vxlan_addr loopback;
	union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;
1909 1910
	struct net_device *dev = skb->dev;
	int len = skb->len;
1911

1912 1913
	tx_stats = this_cpu_ptr(src_vxlan->dev->tstats);
	rx_stats = this_cpu_ptr(dst_vxlan->dev->tstats);
1914 1915 1916 1917 1918
	skb->pkt_type = PACKET_HOST;
	skb->encapsulation = 0;
	skb->dev = dst_vxlan->dev;
	__skb_pull(skb, skb_network_offset(skb));

C
Cong Wang 已提交
1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
	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
	}

1929
	if (dst_vxlan->flags & VXLAN_F_LEARN)
C
Cong Wang 已提交
1930
		vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source);
1931 1932 1933

	u64_stats_update_begin(&tx_stats->syncp);
	tx_stats->tx_packets++;
1934
	tx_stats->tx_bytes += len;
1935 1936 1937 1938 1939
	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++;
1940
		rx_stats->rx_bytes += len;
1941 1942
		u64_stats_update_end(&rx_stats->syncp);
	} else {
1943
		dev->stats.rx_dropped++;
1944 1945 1946
	}
}

1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980
static int encap_bypass_if_local(struct sk_buff *skb, struct net_device *dev,
				 struct vxlan_dev *vxlan, union vxlan_addr *daddr,
				 __be32 dst_port, __be32 vni, struct dst_entry *dst,
				 u32 rt_flags)
{
#if IS_ENABLED(CONFIG_IPV6)
	/* IPv6 rt-flags are checked against RTF_LOCAL, but the value of
	 * RTF_LOCAL is equal to RTCF_LOCAL. So to keep code simple
	 * we can use RTCF_LOCAL which works for ipv4 and ipv6 route entry.
	 */
	BUILD_BUG_ON(RTCF_LOCAL != RTF_LOCAL);
#endif
	/* Bypass encapsulation if the destination is local */
	if (rt_flags & RTCF_LOCAL &&
	    !(rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
		struct vxlan_dev *dst_vxlan;

		dst_release(dst);
		dst_vxlan = vxlan_find_vni(vxlan->net, vni,
					   daddr->sa.sa_family, dst_port,
					   vxlan->flags);
		if (!dst_vxlan) {
			dev->stats.tx_errors++;
			kfree_skb(skb);

			return -ENOENT;
		}
		vxlan_encap_bypass(skb, vxlan, dst_vxlan);
		return 1;
	}

	return 0;
}

1981 1982
static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
			   struct vxlan_rdst *rdst, bool did_rsc)
S
stephen hemminger 已提交
1983
{
1984
	struct dst_cache *dst_cache;
1985
	struct ip_tunnel_info *info;
S
stephen hemminger 已提交
1986
	struct vxlan_dev *vxlan = netdev_priv(dev);
P
pravin shelar 已提交
1987
	const struct iphdr *old_iph = ip_hdr(skb);
C
Cong Wang 已提交
1988
	union vxlan_addr *dst;
1989 1990
	union vxlan_addr remote_ip, local_ip;
	union vxlan_addr *src;
T
Thomas Graf 已提交
1991 1992
	struct vxlan_metadata _md;
	struct vxlan_metadata *md = &_md;
C
Cong Wang 已提交
1993
	__be16 src_port = 0, dst_port;
1994
	struct dst_entry *ndst = NULL;
1995
	__be32 vni, label;
S
stephen hemminger 已提交
1996
	__u8 tos, ttl;
1997
	int err;
T
Thomas Graf 已提交
1998
	u32 flags = vxlan->flags;
1999
	bool udp_sum = false;
2000
	bool xnet = !net_eq(vxlan->net, dev_net(vxlan->dev));
S
stephen hemminger 已提交
2001

2002
	info = skb_tunnel_info(skb);
2003

T
Thomas Graf 已提交
2004
	if (rdst) {
P
pravin shelar 已提交
2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
		dst = &rdst->remote_ip;
		if (vxlan_addr_any(dst)) {
			if (did_rsc) {
				/* short-circuited back to local bridge */
				vxlan_encap_bypass(skb, vxlan, vxlan);
				return;
			}
			goto drop;
		}

2015
		dst_port = rdst->remote_port ? rdst->remote_port : vxlan->cfg.dst_port;
T
Thomas Graf 已提交
2016
		vni = rdst->remote_vni;
2017
		src = &vxlan->cfg.saddr;
2018
		dst_cache = &rdst->dst_cache;
P
pravin shelar 已提交
2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
		md->gbp = skb->mark;
		ttl = vxlan->cfg.ttl;
		if (!ttl && vxlan_addr_multicast(dst))
			ttl = 1;

		tos = vxlan->cfg.tos;
		if (tos == 1)
			tos = ip_tunnel_get_dsfield(old_iph, skb);

		if (dst->sa.sa_family == AF_INET)
			udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM_TX);
		else
			udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM6_TX);
		label = vxlan->cfg.label;
T
Thomas Graf 已提交
2033 2034 2035 2036 2037 2038
	} else {
		if (!info) {
			WARN_ONCE(1, "%s: Missing encapsulation instructions\n",
				  dev->name);
			goto drop;
		}
2039
		remote_ip.sa.sa_family = ip_tunnel_info_af(info);
2040
		if (remote_ip.sa.sa_family == AF_INET) {
2041
			remote_ip.sin.sin_addr.s_addr = info->key.u.ipv4.dst;
2042 2043
			local_ip.sin.sin_addr.s_addr = info->key.u.ipv4.src;
		} else {
2044
			remote_ip.sin6.sin6_addr = info->key.u.ipv6.dst;
2045 2046
			local_ip.sin6.sin6_addr = info->key.u.ipv6.src;
		}
T
Thomas Graf 已提交
2047
		dst = &remote_ip;
P
pravin shelar 已提交
2048 2049
		dst_port = info->key.tp_dst ? : vxlan->cfg.dst_port;
		vni = tunnel_id_to_key32(info->key.tun_id);
2050
		src = &local_ip;
2051
		dst_cache = &info->dst_cache;
P
pravin shelar 已提交
2052 2053
		if (info->options_len)
			md = ip_tunnel_info_opts(info);
2054 2055
		ttl = info->key.ttl;
		tos = info->key.tos;
2056
		label = info->key.label;
2057
		udp_sum = !!(info->key.tun_flags & TUNNEL_CSUM);
2058
	}
P
pravin shelar 已提交
2059 2060
	src_port = udp_flow_src_port(dev_net(dev), skb, vxlan->cfg.port_min,
				     vxlan->cfg.port_max, true);
2061

C
Cong Wang 已提交
2062
	if (dst->sa.sa_family == AF_INET) {
2063
		struct vxlan_sock *sock4 = rcu_dereference(vxlan->vn4_sock);
P
pravin shelar 已提交
2064
		struct rtable *rt;
P
pravin shelar 已提交
2065
		__be16 df = 0;
2066

2067
		rt = vxlan_get_route(vxlan, dev, sock4, skb,
2068
				     rdst ? rdst->remote_ifindex : 0, tos,
2069 2070
				     dst->sin.sin_addr.s_addr,
				     &src->sin.sin_addr.s_addr,
2071
				     dst_cache, info);
2072 2073
		if (IS_ERR(rt)) {
			err = PTR_ERR(rt);
P
pravin shelar 已提交
2074
			goto tx_error;
2075
		}
C
Cong Wang 已提交
2076 2077

		/* Bypass encapsulation if the destination is local */
2078 2079 2080 2081 2082 2083 2084
		if (!info) {
			err = encap_bypass_if_local(skb, dev, vxlan, dst,
						    dst_port, vni, &rt->dst,
						    rt->rt_flags);
			if (err)
				return;
		} else if (info->key.tun_flags & TUNNEL_DONT_FRAGMENT) {
2085
			df = htons(IP_DF);
2086
		}
2087

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

P
pravin shelar 已提交
2096
		udp_tunnel_xmit_skb(rt, sock4->sock->sk, skb, src->sin.sin_addr.s_addr,
2097 2098
				    dst->sin.sin_addr.s_addr, tos, ttl, df,
				    src_port, dst_port, xnet, !udp_sum);
C
Cong Wang 已提交
2099 2100
#if IS_ENABLED(CONFIG_IPV6)
	} else {
2101
		struct vxlan_sock *sock6 = rcu_dereference(vxlan->vn6_sock);
C
Cong Wang 已提交
2102

2103
		ndst = vxlan6_get_route(vxlan, dev, sock6, skb,
2104
					rdst ? rdst->remote_ifindex : 0, tos,
2105 2106
					label, &dst->sin6.sin6_addr,
					&src->sin6.sin6_addr,
2107
					dst_cache, info);
2108
		if (IS_ERR(ndst)) {
2109
			err = PTR_ERR(ndst);
P
pravin shelar 已提交
2110
			ndst = NULL;
2111
			goto tx_error;
C
Cong Wang 已提交
2112
		}
2113

2114 2115
		if (!info) {
			u32 rt6i_flags = ((struct rt6_info *)ndst)->rt6i_flags;
2116

2117 2118 2119 2120 2121 2122
			err = encap_bypass_if_local(skb, dev, vxlan, dst,
						    dst_port, vni, ndst,
						    rt6i_flags);
			if (err)
				return;
		}
2123

2124
		tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
C
Cong Wang 已提交
2125
		ttl = ttl ? : ip6_dst_hoplimit(ndst);
2126 2127
		skb_scrub_packet(skb, xnet);
		err = vxlan_build_skb(skb, ndst, sizeof(struct ipv6hdr),
2128
				      vni, md, flags, udp_sum);
P
pravin shelar 已提交
2129 2130 2131
		if (err < 0)
			goto tx_error;

P
pravin shelar 已提交
2132
		udp_tunnel6_xmit_skb(ndst, sock6->sock->sk, skb, dev,
2133 2134
				     &src->sin6.sin6_addr,
				     &dst->sin6.sin6_addr, tos, ttl,
2135
				     label, src_port, dst_port, !udp_sum);
C
Cong Wang 已提交
2136 2137
#endif
	}
2138
	return;
S
stephen hemminger 已提交
2139 2140 2141

drop:
	dev->stats.tx_dropped++;
P
pravin shelar 已提交
2142 2143
	dev_kfree_skb(skb);
	return;
S
stephen hemminger 已提交
2144 2145

tx_error:
2146 2147 2148 2149
	if (err == -ELOOP)
		dev->stats.collisions++;
	else if (err == -ENETUNREACH)
		dev->stats.tx_carrier_errors++;
P
pravin shelar 已提交
2150
	dst_release(ndst);
S
stephen hemminger 已提交
2151
	dev->stats.tx_errors++;
P
pravin shelar 已提交
2152
	kfree_skb(skb);
S
stephen hemminger 已提交
2153 2154
}

2155 2156 2157 2158 2159 2160 2161 2162 2163
/* 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);
2164
	const struct ip_tunnel_info *info;
2165 2166
	struct ethhdr *eth;
	bool did_rsc = false;
2167
	struct vxlan_rdst *rdst, *fdst = NULL;
2168 2169
	struct vxlan_fdb *f;

2170
	info = skb_tunnel_info(skb);
2171

2172 2173
	skb_reset_mac_header(skb);

2174 2175 2176 2177 2178 2179 2180 2181 2182 2183
	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 已提交
2184 2185 2186 2187
		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 &&
2188 2189
			 pskb_may_pull(skb, sizeof(struct ipv6hdr)
				       + sizeof(struct nd_msg)) &&
C
Cong Wang 已提交
2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
			 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
	}
2200

2201
	eth = eth_hdr(skb);
2202
	f = vxlan_find_mac(vxlan, eth->h_dest);
2203 2204 2205
	did_rsc = false;

	if (f && (f->flags & NTF_ROUTER) && (vxlan->flags & VXLAN_F_RSC) &&
2206 2207
	    (ntohs(eth->h_proto) == ETH_P_IP ||
	     ntohs(eth->h_proto) == ETH_P_IPV6)) {
2208 2209 2210 2211 2212
		did_rsc = route_shortcircuit(dev, skb);
		if (did_rsc)
			f = vxlan_find_mac(vxlan, eth->h_dest);
	}

2213
	if (f == NULL) {
2214 2215 2216 2217 2218 2219 2220
		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++;
2221
			kfree_skb(skb);
2222 2223 2224
			return NETDEV_TX_OK;
		}
	}
2225

2226 2227
	list_for_each_entry_rcu(rdst, &f->remotes, list) {
		struct sk_buff *skb1;
2228

2229 2230 2231 2232
		if (!fdst) {
			fdst = rdst;
			continue;
		}
2233 2234 2235
		skb1 = skb_clone(skb, GFP_ATOMIC);
		if (skb1)
			vxlan_xmit_one(skb1, dev, rdst, did_rsc);
2236 2237
	}

2238 2239 2240 2241
	if (fdst)
		vxlan_xmit_one(skb, dev, fdst, did_rsc);
	else
		kfree_skb(skb);
2242
	return NETDEV_TX_OK;
2243 2244
}

S
stephen hemminger 已提交
2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
/* 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;
2257 2258

		spin_lock_bh(&vxlan->hash_lock);
S
stephen hemminger 已提交
2259 2260 2261 2262 2263
		hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
			struct vxlan_fdb *f
				= container_of(p, struct vxlan_fdb, hlist);
			unsigned long timeout;

2264
			if (f->state & NUD_PERMANENT)
S
stephen hemminger 已提交
2265 2266
				continue;

2267
			timeout = f->used + vxlan->cfg.age_interval * HZ;
S
stephen hemminger 已提交
2268 2269 2270 2271 2272 2273 2274 2275 2276
			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;
		}
2277
		spin_unlock_bh(&vxlan->hash_lock);
S
stephen hemminger 已提交
2278 2279 2280 2281 2282
	}

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

2283 2284
static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan)
{
2285
	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
2286
	__be32 vni = vxlan->default_dst.remote_vni;
2287

2288
	spin_lock(&vn->sock_lock);
2289
	hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));
2290
	spin_unlock(&vn->sock_lock);
2291 2292
}

S
stephen hemminger 已提交
2293 2294 2295
/* Setup stats when device is created */
static int vxlan_init(struct net_device *dev)
{
2296
	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
2297
	if (!dev->tstats)
S
stephen hemminger 已提交
2298 2299 2300 2301 2302
		return -ENOMEM;

	return 0;
}

2303
static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan)
2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
{
	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);
}

2314 2315 2316 2317
static void vxlan_uninit(struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);

2318
	vxlan_fdb_delete_default(vxlan);
2319

2320 2321 2322
	free_percpu(dev->tstats);
}

S
stephen hemminger 已提交
2323 2324 2325 2326
/* 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);
2327
	int ret;
2328

2329 2330 2331
	ret = vxlan_sock_add(vxlan);
	if (ret < 0)
		return ret;
S
stephen hemminger 已提交
2332

2333
	if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip)) {
2334
		ret = vxlan_igmp_join(vxlan);
2335 2336
		if (ret == -EADDRINUSE)
			ret = 0;
2337
		if (ret) {
2338
			vxlan_sock_release(vxlan);
2339 2340
			return ret;
		}
S
stephen hemminger 已提交
2341 2342
	}

2343
	if (vxlan->cfg.age_interval)
S
stephen hemminger 已提交
2344 2345
		mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);

2346
	return ret;
S
stephen hemminger 已提交
2347 2348 2349 2350 2351
}

/* Purge the forwarding table */
static void vxlan_flush(struct vxlan_dev *vxlan)
{
2352
	unsigned int h;
S
stephen hemminger 已提交
2353 2354 2355 2356 2357 2358 2359

	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);
2360 2361 2362
			/* 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 已提交
2363 2364 2365 2366 2367 2368 2369 2370 2371
		}
	}
	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 已提交
2372
	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
2373
	int ret = 0;
S
stephen hemminger 已提交
2374

2375
	if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&
2376
	    !vxlan_group_used(vn, vxlan))
2377
		ret = vxlan_igmp_leave(vxlan);
S
stephen hemminger 已提交
2378 2379 2380 2381

	del_timer_sync(&vxlan->age_timer);

	vxlan_flush(vxlan);
2382
	vxlan_sock_release(vxlan);
S
stephen hemminger 已提交
2383

2384
	return ret;
S
stephen hemminger 已提交
2385 2386 2387 2388 2389 2390 2391
}

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

2392
static int vxlan_change_mtu(struct net_device *dev, int new_mtu)
2393
{
2394 2395 2396 2397 2398
	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);
	bool use_ipv6 = false;
2399 2400

	if (dst->remote_ip.sa.sa_family == AF_INET6)
2401
		use_ipv6 = true;
2402

2403 2404 2405 2406 2407 2408 2409
	/* This check is different than dev->max_mtu, because it looks at
	 * the lowerdev->mtu, rather than the static dev->max_mtu
	 */
	if (lowerdev) {
		int max_mtu = lowerdev->mtu -
			      (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
		if (new_mtu > max_mtu)
D
David Wragg 已提交
2410 2411 2412
			return -EINVAL;
	}

2413 2414 2415 2416
	dev->mtu = new_mtu;
	return 0;
}

2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
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;

2427
	if (ip_tunnel_info_af(info) == AF_INET) {
2428
		struct vxlan_sock *sock4 = rcu_dereference(vxlan->vn4_sock);
2429 2430
		struct rtable *rt;

2431
		rt = vxlan_get_route(vxlan, dev, sock4, skb, 0, info->key.tos,
2432
				     info->key.u.ipv4.dst,
2433
				     &info->key.u.ipv4.src, NULL, info);
2434 2435 2436
		if (IS_ERR(rt))
			return PTR_ERR(rt);
		ip_rt_put(rt);
2437 2438
	} else {
#if IS_ENABLED(CONFIG_IPV6)
2439
		struct vxlan_sock *sock6 = rcu_dereference(vxlan->vn6_sock);
2440 2441
		struct dst_entry *ndst;

2442
		ndst = vxlan6_get_route(vxlan, dev, sock6, skb, 0, info->key.tos,
2443
					info->key.label, &info->key.u.ipv6.dst,
2444
					&info->key.u.ipv6.src, NULL, info);
2445 2446 2447 2448 2449 2450 2451
		if (IS_ERR(ndst))
			return PTR_ERR(ndst);
		dst_release(ndst);
#else /* !CONFIG_IPV6 */
		return -EPFNOSUPPORT;
#endif
	}
2452 2453
	info->key.tp_src = sport;
	info->key.tp_dst = dport;
2454
	return 0;
2455 2456
}

2457
static const struct net_device_ops vxlan_netdev_ether_ops = {
S
stephen hemminger 已提交
2458
	.ndo_init		= vxlan_init,
2459
	.ndo_uninit		= vxlan_uninit,
S
stephen hemminger 已提交
2460 2461 2462
	.ndo_open		= vxlan_open,
	.ndo_stop		= vxlan_stop,
	.ndo_start_xmit		= vxlan_xmit,
2463
	.ndo_get_stats64	= ip_tunnel_get_stats64,
S
stephen hemminger 已提交
2464
	.ndo_set_rx_mode	= vxlan_set_multicast_list,
2465
	.ndo_change_mtu		= vxlan_change_mtu,
S
stephen hemminger 已提交
2466 2467 2468 2469 2470
	.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,
2471
	.ndo_fill_metadata_dst	= vxlan_fill_metadata_dst,
S
stephen hemminger 已提交
2472 2473
};

J
Jiri Benc 已提交
2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484
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 已提交
2485 2486 2487 2488 2489
/* Info for udev, that this is a virtual tunnel endpoint */
static struct device_type vxlan_type = {
	.name = "vxlan",
};

2490
/* Calls the ndo_udp_tunnel_add of the caller in order to
J
Joseph Gasparakis 已提交
2491
 * supply the listening VXLAN udp ports. Callers are expected
2492
 * to implement the ndo_udp_tunnel_add.
2493
 */
2494
static void vxlan_push_rx_ports(struct net_device *dev)
2495 2496 2497 2498
{
	struct vxlan_sock *vs;
	struct net *net = dev_net(dev);
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
J
Joseph Gasparakis 已提交
2499
	unsigned int i;
2500 2501 2502

	spin_lock(&vn->sock_lock);
	for (i = 0; i < PORT_HASH_SIZE; ++i) {
2503 2504
		hlist_for_each_entry_rcu(vs, &vn->sock_list[i], hlist)
			udp_tunnel_push_rx_port(dev, vs->sock,
2505 2506
						(vs->flags & VXLAN_F_GPE) ?
						UDP_TUNNEL_TYPE_VXLAN_GPE :
2507
						UDP_TUNNEL_TYPE_VXLAN);
2508 2509 2510 2511
	}
	spin_unlock(&vn->sock_lock);
}

S
stephen hemminger 已提交
2512 2513 2514 2515
/* Initialize the device structure. */
static void vxlan_setup(struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
2516
	unsigned int h;
S
stephen hemminger 已提交
2517

2518 2519 2520
	eth_hw_addr_random(dev);
	ether_setup(dev);

2521
	dev->destructor = free_netdev;
S
stephen hemminger 已提交
2522 2523 2524
	SET_NETDEV_DEVTYPE(dev, &vxlan_type);

	dev->features	|= NETIF_F_LLTX;
2525
	dev->features	|= NETIF_F_SG | NETIF_F_HW_CSUM;
2526
	dev->features   |= NETIF_F_RXCSUM;
2527
	dev->features   |= NETIF_F_GSO_SOFTWARE;
2528

2529
	dev->vlan_features = dev->features;
2530
	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
2531
	dev->hw_features |= NETIF_F_GSO_SOFTWARE;
2532
	netif_keep_dst(dev);
2533
	dev->priv_flags |= IFF_NO_QUEUE;
S
stephen hemminger 已提交
2534

2535
	INIT_LIST_HEAD(&vxlan->next);
S
stephen hemminger 已提交
2536 2537 2538 2539 2540 2541
	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;

2542
	vxlan->cfg.dst_port = htons(vxlan_port);
2543

S
stephen hemminger 已提交
2544 2545
	vxlan->dev = dev;

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

S
stephen hemminger 已提交
2548 2549 2550 2551
	for (h = 0; h < FDB_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&vxlan->fdb_head[h]);
}

2552 2553 2554 2555 2556 2557 2558
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 已提交
2559 2560
static void vxlan_raw_setup(struct net_device *dev)
{
2561
	dev->header_ops = NULL;
J
Jiri Benc 已提交
2562 2563 2564 2565 2566 2567 2568
	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 已提交
2569 2570
static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
	[IFLA_VXLAN_ID]		= { .type = NLA_U32 },
2571
	[IFLA_VXLAN_GROUP]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
C
Cong Wang 已提交
2572
	[IFLA_VXLAN_GROUP6]	= { .len = sizeof(struct in6_addr) },
S
stephen hemminger 已提交
2573 2574
	[IFLA_VXLAN_LINK]	= { .type = NLA_U32 },
	[IFLA_VXLAN_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
C
Cong Wang 已提交
2575
	[IFLA_VXLAN_LOCAL6]	= { .len = sizeof(struct in6_addr) },
S
stephen hemminger 已提交
2576 2577
	[IFLA_VXLAN_TOS]	= { .type = NLA_U8 },
	[IFLA_VXLAN_TTL]	= { .type = NLA_U8 },
2578
	[IFLA_VXLAN_LABEL]	= { .type = NLA_U32 },
S
stephen hemminger 已提交
2579 2580 2581
	[IFLA_VXLAN_LEARNING]	= { .type = NLA_U8 },
	[IFLA_VXLAN_AGEING]	= { .type = NLA_U32 },
	[IFLA_VXLAN_LIMIT]	= { .type = NLA_U32 },
2582
	[IFLA_VXLAN_PORT_RANGE] = { .len  = sizeof(struct ifla_vxlan_port_range) },
D
David Stevens 已提交
2583 2584 2585 2586
	[IFLA_VXLAN_PROXY]	= { .type = NLA_U8 },
	[IFLA_VXLAN_RSC]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L2MISS]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L3MISS]	= { .type = NLA_U8 },
2587
	[IFLA_VXLAN_COLLECT_METADATA]	= { .type = NLA_U8 },
2588
	[IFLA_VXLAN_PORT]	= { .type = NLA_U16 },
2589 2590 2591
	[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 已提交
2592 2593
	[IFLA_VXLAN_REMCSUM_TX]	= { .type = NLA_U8 },
	[IFLA_VXLAN_REMCSUM_RX]	= { .type = NLA_U8 },
T
Thomas Graf 已提交
2594
	[IFLA_VXLAN_GBP]	= { .type = NLA_FLAG, },
J
Jiri Benc 已提交
2595
	[IFLA_VXLAN_GPE]	= { .type = NLA_FLAG, },
2596
	[IFLA_VXLAN_REMCSUM_NOPARTIAL]	= { .type = NLA_FLAG },
S
stephen hemminger 已提交
2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621
};

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;
	}

2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632
	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 已提交
2633 2634 2635
	return 0;
}

Y
Yan Burman 已提交
2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647
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 已提交
2648 2649
static struct socket *vxlan_create_sock(struct net *net, bool ipv6,
					__be16 port, u32 flags)
2650
{
C
Cong Wang 已提交
2651
	struct socket *sock;
T
Tom Herbert 已提交
2652 2653
	struct udp_port_cfg udp_conf;
	int err;
C
Cong Wang 已提交
2654

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

T
Tom Herbert 已提交
2657 2658 2659
	if (ipv6) {
		udp_conf.family = AF_INET6;
		udp_conf.use_udp6_rx_checksums =
2660
		    !(flags & VXLAN_F_UDP_ZERO_CSUM6_RX);
2661
		udp_conf.ipv6_v6only = 1;
T
Tom Herbert 已提交
2662 2663
	} else {
		udp_conf.family = AF_INET;
C
Cong Wang 已提交
2664 2665
	}

T
Tom Herbert 已提交
2666
	udp_conf.local_udp_port = port;
2667

T
Tom Herbert 已提交
2668 2669 2670 2671
	/* Open UDP socket */
	err = udp_sock_create(net, &udp_conf, &sock);
	if (err < 0)
		return ERR_PTR(err);
C
Cong Wang 已提交
2672

Z
Zhi Yong Wu 已提交
2673
	return sock;
C
Cong Wang 已提交
2674 2675 2676
}

/* Create new listen socket if needed */
2677 2678
static struct vxlan_sock *vxlan_socket_create(struct net *net, bool ipv6,
					      __be16 port, u32 flags)
C
Cong Wang 已提交
2679 2680 2681 2682 2683
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
	struct vxlan_sock *vs;
	struct socket *sock;
	unsigned int h;
2684
	struct udp_tunnel_sock_cfg tunnel_cfg;
C
Cong Wang 已提交
2685

2686
	vs = kzalloc(sizeof(*vs), GFP_KERNEL);
C
Cong Wang 已提交
2687 2688 2689 2690 2691 2692
	if (!vs)
		return ERR_PTR(-ENOMEM);

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

T
Tom Herbert 已提交
2693
	sock = vxlan_create_sock(net, ipv6, port, flags);
Z
Zhi Yong Wu 已提交
2694
	if (IS_ERR(sock)) {
2695 2696
		pr_info("Cannot bind port %d, err=%ld\n", ntohs(port),
			PTR_ERR(sock));
2697
		kfree(vs);
2698
		return ERR_CAST(sock);
2699
	}
C
Cong Wang 已提交
2700 2701

	vs->sock = sock;
2702
	atomic_set(&vs->refcnt, 1);
2703
	vs->flags = (flags & VXLAN_F_RCV_FLAGS);
2704

2705 2706
	spin_lock(&vn->sock_lock);
	hlist_add_head_rcu(&vs->hlist, vs_head(net, port));
2707
	udp_tunnel_notify_add_rx_port(sock,
2708 2709
				      (vs->flags & VXLAN_F_GPE) ?
				      UDP_TUNNEL_TYPE_VXLAN_GPE :
2710
				      UDP_TUNNEL_TYPE_VXLAN);
2711
	spin_unlock(&vn->sock_lock);
2712 2713

	/* Mark socket as an encapsulation socket. */
2714
	memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
2715 2716
	tunnel_cfg.sk_user_data = vs;
	tunnel_cfg.encap_type = 1;
2717
	tunnel_cfg.encap_rcv = vxlan_rcv;
2718
	tunnel_cfg.encap_destroy = NULL;
2719 2720
	tunnel_cfg.gro_receive = vxlan_gro_receive;
	tunnel_cfg.gro_complete = vxlan_gro_complete;
2721 2722

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

2724 2725 2726
	return vs;
}

2727
static int __vxlan_sock_add(struct vxlan_dev *vxlan, bool ipv6)
2728
{
2729 2730
	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
	struct vxlan_sock *vs = NULL;
2731

2732
	if (!vxlan->cfg.no_share) {
2733
		spin_lock(&vn->sock_lock);
2734 2735 2736
		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)) {
2737
			spin_unlock(&vn->sock_lock);
2738
			return -EBUSY;
2739 2740 2741
		}
		spin_unlock(&vn->sock_lock);
	}
2742
	if (!vs)
2743 2744
		vs = vxlan_socket_create(vxlan->net, ipv6,
					 vxlan->cfg.dst_port, vxlan->flags);
2745 2746
	if (IS_ERR(vs))
		return PTR_ERR(vs);
2747 2748
#if IS_ENABLED(CONFIG_IPV6)
	if (ipv6)
2749
		rcu_assign_pointer(vxlan->vn6_sock, vs);
2750 2751
	else
#endif
2752
		rcu_assign_pointer(vxlan->vn4_sock, vs);
2753 2754
	vxlan_vs_add_dev(vs, vxlan);
	return 0;
2755 2756
}

2757 2758 2759 2760 2761 2762
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;

2763
	RCU_INIT_POINTER(vxlan->vn4_sock, NULL);
2764
#if IS_ENABLED(CONFIG_IPV6)
2765
	RCU_INIT_POINTER(vxlan->vn6_sock, NULL);
2766 2767 2768 2769 2770 2771 2772 2773 2774 2775
	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;
}

2776 2777
static int vxlan_dev_configure(struct net *src_net, struct net_device *dev,
			       struct vxlan_config *conf)
S
stephen hemminger 已提交
2778
{
2779
	struct vxlan_net *vn = net_generic(src_net, vxlan_net_id);
2780
	struct vxlan_dev *vxlan = netdev_priv(dev), *tmp;
2781
	struct vxlan_rdst *dst = &vxlan->default_dst;
2782
	unsigned short needed_headroom = ETH_HLEN;
S
stephen hemminger 已提交
2783
	int err;
C
Cong Wang 已提交
2784
	bool use_ipv6 = false;
2785
	__be16 default_port = vxlan->cfg.dst_port;
2786
	struct net_device *lowerdev = NULL;
S
stephen hemminger 已提交
2787

J
Jiri Benc 已提交
2788 2789 2790 2791 2792
	if (conf->flags & VXLAN_F_GPE) {
		/* 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.
		 */
2793 2794 2795
		if ((conf->flags & ~VXLAN_F_ALLOWED_GPE) ||
		    !(conf->flags & VXLAN_F_COLLECT_METADATA)) {
			pr_info("unsupported combination of extensions\n");
J
Jiri Benc 已提交
2796
			return -EINVAL;
2797
		}
J
Jiri Benc 已提交
2798 2799 2800 2801 2802

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

2804 2805 2806 2807
	/* MTU range: 68 - 65535 */
	dev->min_mtu = ETH_MIN_MTU;
	dev->max_mtu = ETH_MAX_MTU;

2808
	vxlan->net = src_net;
N
Nicolas Dichtel 已提交
2809

2810
	dst->remote_vni = conf->vni;
S
stephen hemminger 已提交
2811

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

2814 2815 2816
	/* 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 已提交
2817

2818
	if (dst->remote_ip.sa.sa_family == AF_INET6 ||
2819 2820 2821
	    vxlan->cfg.saddr.sa.sa_family == AF_INET6) {
		if (!IS_ENABLED(CONFIG_IPV6))
			return -EPFNOSUPPORT;
C
Cong Wang 已提交
2822
		use_ipv6 = true;
2823
		vxlan->flags |= VXLAN_F_IPV6;
2824
	}
S
stephen hemminger 已提交
2825

2826 2827 2828 2829 2830
	if (conf->label && !use_ipv6) {
		pr_info("label only supported in use with IPv6\n");
		return -EINVAL;
	}

2831
	if (conf->remote_ifindex) {
2832
		lowerdev = __dev_get_by_index(src_net, conf->remote_ifindex);
2833
		dst->remote_ifindex = conf->remote_ifindex;
2834 2835

		if (!lowerdev) {
2836
			pr_info("ifindex %d does not exist\n", dst->remote_ifindex);
2837 2838
			return -ENODEV;
		}
S
stephen hemminger 已提交
2839

C
Cong Wang 已提交
2840 2841 2842 2843 2844 2845 2846 2847 2848 2849
#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

2850
		if (!conf->mtu)
2851 2852
			dev->mtu = lowerdev->mtu -
				   (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
2853

2854
		needed_headroom = lowerdev->hard_header_len;
2855 2856 2857
	} else if (vxlan_addr_multicast(&dst->remote_ip)) {
		pr_info("multicast destination requires interface to be specified\n");
		return -EINVAL;
J
Jiri Benc 已提交
2858
	}
S
stephen hemminger 已提交
2859

2860
	if (conf->mtu) {
2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874
		int max_mtu = ETH_MAX_MTU;

		if (lowerdev)
			max_mtu = lowerdev->mtu;

		max_mtu -= (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);

		if (conf->mtu < dev->min_mtu || conf->mtu > dev->max_mtu)
			return -EINVAL;

		dev->mtu = conf->mtu;

		if (conf->mtu > max_mtu)
			dev->mtu = max_mtu;
2875 2876
	}

2877 2878 2879 2880 2881 2882
	if (use_ipv6 || conf->flags & VXLAN_F_COLLECT_METADATA)
		needed_headroom += VXLAN6_HEADROOM;
	else
		needed_headroom += VXLAN_HEADROOM;
	dev->needed_headroom = needed_headroom;

2883
	memcpy(&vxlan->cfg, conf, sizeof(*conf));
J
Jiri Benc 已提交
2884 2885 2886 2887 2888 2889
	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;
	}
2890 2891 2892 2893 2894
	vxlan->flags |= conf->flags;

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

2895 2896 2897 2898 2899 2900
	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) ==
2901 2902 2903 2904
		    (vxlan->flags & VXLAN_F_RCV_FLAGS)) {
			pr_info("duplicate VNI %u\n", be32_to_cpu(conf->vni));
			return -EEXIST;
		}
2905
	}
2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939

	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;
}

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

	memset(&conf, 0, sizeof(conf));
2940 2941

	if (data[IFLA_VXLAN_ID])
2942
		conf.vni = cpu_to_be32(nla_get_u32(data[IFLA_VXLAN_ID]));
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

	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 已提交
2969
	if (data[IFLA_VXLAN_TOS])
2970
		conf.tos  = nla_get_u8(data[IFLA_VXLAN_TOS]);
S
stephen hemminger 已提交
2971

2972
	if (data[IFLA_VXLAN_TTL])
2973
		conf.ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);
2974

2975 2976 2977 2978
	if (data[IFLA_VXLAN_LABEL])
		conf.label = nla_get_be32(data[IFLA_VXLAN_LABEL]) &
			     IPV6_FLOWLABEL_MASK;

S
stephen hemminger 已提交
2979
	if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))
2980
		conf.flags |= VXLAN_F_LEARN;
S
stephen hemminger 已提交
2981 2982

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

D
David Stevens 已提交
2985
	if (data[IFLA_VXLAN_PROXY] && nla_get_u8(data[IFLA_VXLAN_PROXY]))
2986
		conf.flags |= VXLAN_F_PROXY;
D
David Stevens 已提交
2987 2988

	if (data[IFLA_VXLAN_RSC] && nla_get_u8(data[IFLA_VXLAN_RSC]))
2989
		conf.flags |= VXLAN_F_RSC;
D
David Stevens 已提交
2990 2991

	if (data[IFLA_VXLAN_L2MISS] && nla_get_u8(data[IFLA_VXLAN_L2MISS]))
2992
		conf.flags |= VXLAN_F_L2MISS;
D
David Stevens 已提交
2993 2994

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

S
stephen hemminger 已提交
2997
	if (data[IFLA_VXLAN_LIMIT])
2998
		conf.addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);
S
stephen hemminger 已提交
2999

3000 3001 3002 3003
	if (data[IFLA_VXLAN_COLLECT_METADATA] &&
	    nla_get_u8(data[IFLA_VXLAN_COLLECT_METADATA]))
		conf.flags |= VXLAN_F_COLLECT_METADATA;

3004 3005 3006
	if (data[IFLA_VXLAN_PORT_RANGE]) {
		const struct ifla_vxlan_port_range *p
			= nla_data(data[IFLA_VXLAN_PORT_RANGE]);
3007 3008
		conf.port_min = ntohs(p->low);
		conf.port_max = ntohs(p->high);
3009 3010
	}

3011
	if (data[IFLA_VXLAN_PORT])
3012
		conf.dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);
3013

3014 3015 3016
	if (data[IFLA_VXLAN_UDP_CSUM] &&
	    !nla_get_u8(data[IFLA_VXLAN_UDP_CSUM]))
		conf.flags |= VXLAN_F_UDP_ZERO_CSUM_TX;
3017 3018 3019

	if (data[IFLA_VXLAN_UDP_ZERO_CSUM6_TX] &&
	    nla_get_u8(data[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]))
3020
		conf.flags |= VXLAN_F_UDP_ZERO_CSUM6_TX;
3021 3022 3023

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

T
Tom Herbert 已提交
3026 3027
	if (data[IFLA_VXLAN_REMCSUM_TX] &&
	    nla_get_u8(data[IFLA_VXLAN_REMCSUM_TX]))
3028
		conf.flags |= VXLAN_F_REMCSUM_TX;
T
Tom Herbert 已提交
3029 3030 3031

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

T
Thomas Graf 已提交
3034
	if (data[IFLA_VXLAN_GBP])
3035
		conf.flags |= VXLAN_F_GBP;
T
Thomas Graf 已提交
3036

J
Jiri Benc 已提交
3037 3038 3039
	if (data[IFLA_VXLAN_GPE])
		conf.flags |= VXLAN_F_GPE;

3040
	if (data[IFLA_VXLAN_REMCSUM_NOPARTIAL])
3041
		conf.flags |= VXLAN_F_REMCSUM_NOPARTIAL;
3042

3043 3044 3045
	if (tb[IFLA_MTU])
		conf.mtu = nla_get_u32(tb[IFLA_MTU]);

3046
	return vxlan_dev_configure(src_net, dev, &conf);
S
stephen hemminger 已提交
3047 3048 3049 3050 3051
}

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

3054
	spin_lock(&vn->sock_lock);
3055 3056
	if (!hlist_unhashed(&vxlan->hlist))
		hlist_del_rcu(&vxlan->hlist);
3057 3058
	spin_unlock(&vn->sock_lock);

T
Tom Herbert 已提交
3059
	gro_cells_destroy(&vxlan->gro_cells);
3060
	list_del(&vxlan->next);
S
stephen hemminger 已提交
3061 3062 3063 3064 3065 3066 3067
	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 已提交
3068
		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */
S
stephen hemminger 已提交
3069
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LINK */
C
Cong Wang 已提交
3070
		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */
S
stephen hemminger 已提交
3071 3072
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TTL */
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TOS */
3073
		nla_total_size(sizeof(__be32)) + /* IFLA_VXLAN_LABEL */
S
stephen hemminger 已提交
3074
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_LEARNING */
D
David Stevens 已提交
3075 3076 3077 3078
		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 */
3079
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_COLLECT_METADATA */
S
stephen hemminger 已提交
3080 3081
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_AGEING */
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LIMIT */
3082
		nla_total_size(sizeof(struct ifla_vxlan_port_range)) +
3083 3084 3085 3086
		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 已提交
3087 3088
		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_TX */
		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_RX */
S
stephen hemminger 已提交
3089 3090 3091 3092 3093 3094
		0;
}

static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
{
	const struct vxlan_dev *vxlan = netdev_priv(dev);
3095
	const struct vxlan_rdst *dst = &vxlan->default_dst;
3096
	struct ifla_vxlan_port_range ports = {
3097 3098
		.low =  htons(vxlan->cfg.port_min),
		.high = htons(vxlan->cfg.port_max),
3099
	};
S
stephen hemminger 已提交
3100

3101
	if (nla_put_u32(skb, IFLA_VXLAN_ID, be32_to_cpu(dst->remote_vni)))
S
stephen hemminger 已提交
3102 3103
		goto nla_put_failure;

C
Cong Wang 已提交
3104 3105
	if (!vxlan_addr_any(&dst->remote_ip)) {
		if (dst->remote_ip.sa.sa_family == AF_INET) {
3106 3107
			if (nla_put_in_addr(skb, IFLA_VXLAN_GROUP,
					    dst->remote_ip.sin.sin_addr.s_addr))
C
Cong Wang 已提交
3108 3109 3110
				goto nla_put_failure;
#if IS_ENABLED(CONFIG_IPV6)
		} else {
3111 3112
			if (nla_put_in6_addr(skb, IFLA_VXLAN_GROUP6,
					     &dst->remote_ip.sin6.sin6_addr))
C
Cong Wang 已提交
3113 3114 3115 3116
				goto nla_put_failure;
#endif
		}
	}
S
stephen hemminger 已提交
3117

3118
	if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))
S
stephen hemminger 已提交
3119 3120
		goto nla_put_failure;

3121 3122
	if (!vxlan_addr_any(&vxlan->cfg.saddr)) {
		if (vxlan->cfg.saddr.sa.sa_family == AF_INET) {
3123
			if (nla_put_in_addr(skb, IFLA_VXLAN_LOCAL,
3124
					    vxlan->cfg.saddr.sin.sin_addr.s_addr))
C
Cong Wang 已提交
3125 3126 3127
				goto nla_put_failure;
#if IS_ENABLED(CONFIG_IPV6)
		} else {
3128
			if (nla_put_in6_addr(skb, IFLA_VXLAN_LOCAL6,
3129
					     &vxlan->cfg.saddr.sin6.sin6_addr))
C
Cong Wang 已提交
3130 3131 3132 3133
				goto nla_put_failure;
#endif
		}
	}
S
stephen hemminger 已提交
3134

3135 3136
	if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->cfg.ttl) ||
	    nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->cfg.tos) ||
3137
	    nla_put_be32(skb, IFLA_VXLAN_LABEL, vxlan->cfg.label) ||
D
David Stevens 已提交
3138 3139 3140 3141 3142 3143 3144 3145 3146
	    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)) ||
3147 3148
	    nla_put_u8(skb, IFLA_VXLAN_COLLECT_METADATA,
		       !!(vxlan->flags & VXLAN_F_COLLECT_METADATA)) ||
3149 3150 3151
	    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) ||
3152
	    nla_put_u8(skb, IFLA_VXLAN_UDP_CSUM,
3153
			!(vxlan->flags & VXLAN_F_UDP_ZERO_CSUM_TX)) ||
3154 3155 3156
	    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 已提交
3157 3158 3159 3160 3161
			!!(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 已提交
3162 3163
		goto nla_put_failure;

3164 3165 3166
	if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))
		goto nla_put_failure;

T
Thomas Graf 已提交
3167 3168 3169 3170
	if (vxlan->flags & VXLAN_F_GBP &&
	    nla_put_flag(skb, IFLA_VXLAN_GBP))
		goto nla_put_failure;

J
Jiri Benc 已提交
3171 3172 3173 3174
	if (vxlan->flags & VXLAN_F_GPE &&
	    nla_put_flag(skb, IFLA_VXLAN_GPE))
		goto nla_put_failure;

3175 3176 3177 3178
	if (vxlan->flags & VXLAN_F_REMCSUM_NOPARTIAL &&
	    nla_put_flag(skb, IFLA_VXLAN_REMCSUM_NOPARTIAL))
		goto nla_put_failure;

S
stephen hemminger 已提交
3179 3180 3181 3182 3183 3184
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

3185 3186 3187 3188 3189 3190 3191
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 已提交
3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202
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,
3203
	.get_link_net	= vxlan_get_link_net,
S
stephen hemminger 已提交
3204 3205
};

3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239
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);
	}

	err = rtnl_configure_link(dev, NULL);
	if (err < 0) {
		LIST_HEAD(list_kill);

		vxlan_dellink(dev, &list_kill);
		unregister_netdevice_many(&list_kill);
		return ERR_PTR(err);
	}

	return dev;
}
EXPORT_SYMBOL_GPL(vxlan_dev_create);

3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261
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);
}

3262 3263
static int vxlan_netdevice_event(struct notifier_block *unused,
				 unsigned long event, void *ptr)
3264 3265
{
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3266
	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
3267

3268
	if (event == NETDEV_UNREGISTER)
3269
		vxlan_handle_lowerdev_unregister(vn, dev);
3270
	else if (event == NETDEV_UDP_TUNNEL_PUSH_INFO)
3271
		vxlan_push_rx_ports(dev);
3272 3273 3274 3275 3276

	return NOTIFY_DONE;
}

static struct notifier_block vxlan_notifier_block __read_mostly = {
3277
	.notifier_call = vxlan_netdevice_event,
3278 3279
};

S
stephen hemminger 已提交
3280 3281 3282
static __net_init int vxlan_init_net(struct net *net)
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
3283
	unsigned int h;
S
stephen hemminger 已提交
3284

3285
	INIT_LIST_HEAD(&vn->vxlan_list);
3286
	spin_lock_init(&vn->sock_lock);
S
stephen hemminger 已提交
3287

3288 3289
	for (h = 0; h < PORT_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&vn->sock_list[h]);
S
stephen hemminger 已提交
3290 3291 3292 3293

	return 0;
}

N
Nicolas Dichtel 已提交
3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309
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 已提交
3310 3311
		if (!net_eq(dev_net(vxlan->dev), net)) {
			gro_cells_destroy(&vxlan->gro_cells);
3312
			unregister_netdevice_queue(vxlan->dev, &list);
T
Tom Herbert 已提交
3313
		}
N
Nicolas Dichtel 已提交
3314 3315 3316 3317 3318 3319
	}

	unregister_netdevice_many(&list);
	rtnl_unlock();
}

S
stephen hemminger 已提交
3320 3321
static struct pernet_operations vxlan_net_ops = {
	.init = vxlan_init_net,
N
Nicolas Dichtel 已提交
3322
	.exit = vxlan_exit_net,
S
stephen hemminger 已提交
3323 3324 3325 3326 3327 3328 3329 3330 3331 3332
	.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));

3333
	rc = register_pernet_subsys(&vxlan_net_ops);
S
stephen hemminger 已提交
3334 3335 3336
	if (rc)
		goto out1;

3337
	rc = register_netdevice_notifier(&vxlan_notifier_block);
S
stephen hemminger 已提交
3338 3339 3340
	if (rc)
		goto out2;

3341 3342 3343
	rc = rtnl_link_register(&vxlan_link_ops);
	if (rc)
		goto out3;
S
stephen hemminger 已提交
3344

3345 3346 3347
	return 0;
out3:
	unregister_netdevice_notifier(&vxlan_notifier_block);
S
stephen hemminger 已提交
3348
out2:
3349
	unregister_pernet_subsys(&vxlan_net_ops);
S
stephen hemminger 已提交
3350 3351 3352
out1:
	return rc;
}
3353
late_initcall(vxlan_init_module);
S
stephen hemminger 已提交
3354 3355 3356

static void __exit vxlan_cleanup_module(void)
{
3357
	rtnl_link_unregister(&vxlan_link_ops);
3358
	unregister_netdevice_notifier(&vxlan_notifier_block);
3359 3360
	unregister_pernet_subsys(&vxlan_net_ops);
	/* rcu_barrier() is called by netns */
S
stephen hemminger 已提交
3361 3362 3363 3364 3365
}
module_exit(vxlan_cleanup_module);

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