vxlan.c 44.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 20 21 22 23 24 25 26 27 28 29 30
 *
 * 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.
 *
 * TODO
 *  - IPv6 (not in RFC)
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/rculist.h>
#include <linux/netdevice.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <linux/igmp.h>
#include <linux/etherdevice.h>
#include <linux/if_ether.h>
#include <linux/hash.h>
Y
Yan Burman 已提交
31
#include <linux/ethtool.h>
D
David Stevens 已提交
32 33
#include <net/arp.h>
#include <net/ndisc.h>
S
stephen hemminger 已提交
34
#include <net/ip.h>
35
#include <net/ip_tunnels.h>
S
stephen hemminger 已提交
36 37 38 39 40 41 42 43 44 45 46
#include <net/icmp.h>
#include <net/udp.h>
#include <net/rtnetlink.h>
#include <net/route.h>
#include <net/dsfield.h>
#include <net/inet_ecn.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>

#define VXLAN_VERSION	"0.1"

47 48
#define PORT_HASH_BITS	8
#define PORT_HASH_SIZE  (1<<PORT_HASH_BITS)
S
stephen hemminger 已提交
49 50 51 52 53 54 55 56 57
#define VNI_HASH_BITS	10
#define VNI_HASH_SIZE	(1<<VNI_HASH_BITS)
#define FDB_HASH_BITS	8
#define FDB_HASH_SIZE	(1<<FDB_HASH_BITS)
#define FDB_AGE_DEFAULT 300 /* 5 min */
#define FDB_AGE_INTERVAL (10 * HZ)	/* rescan interval */

#define VXLAN_N_VID	(1u << 24)
#define VXLAN_VID_MASK	(VXLAN_N_VID - 1)
58 59
/* IP header + UDP + VXLAN + Ethernet header */
#define VXLAN_HEADROOM (20 + 8 + 8 + 14)
S
stephen hemminger 已提交
60 61 62 63 64 65 66 67 68

#define VXLAN_FLAGS 0x08000000	/* struct vxlanhdr.vx_flags required value. */

/* VXLAN protocol header */
struct vxlanhdr {
	__be32 vx_flags;
	__be32 vx_vni;
};

69 70 71 72
/* UDP port for VXLAN traffic.
 * The IANA assigned port is 4789, but the Linux default is 8472
 * for compatability with early adopters.
 */
S
stephen hemminger 已提交
73 74 75 76 77 78 79 80 81
static unsigned int vxlan_port __read_mostly = 8472;
module_param_named(udp_port, vxlan_port, uint, 0444);
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");

static unsigned int vxlan_net_id;
82 83 84 85 86 87

/* per UDP socket information */
struct vxlan_sock {
	struct hlist_node hlist;
	struct rcu_head	  rcu;
	struct work_struct del_work;
88
	atomic_t	  refcnt;
89
	struct socket	  *sock;
S
stephen hemminger 已提交
90 91 92
	struct hlist_head vni_list[VNI_HASH_SIZE];
};

93 94 95 96
/* per-network namespace private data for this module */
struct vxlan_net {
	struct list_head  vxlan_list;
	struct hlist_head sock_list[PORT_HASH_SIZE];
97
	spinlock_t	  sock_lock;
98 99
};

100 101 102 103 104 105 106 107
struct vxlan_rdst {
	__be32			 remote_ip;
	__be16			 remote_port;
	u32			 remote_vni;
	u32			 remote_ifindex;
	struct vxlan_rdst	*remote_next;
};

S
stephen hemminger 已提交
108 109 110 111 112 113
/* 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;
114
	struct vxlan_rdst remote;
S
stephen hemminger 已提交
115
	u16		  state;	/* see ndm_state */
116
	u8		  flags;	/* see ndm_flags */
S
stephen hemminger 已提交
117 118 119 120 121
	u8		  eth_addr[ETH_ALEN];
};

/* Pseudo network device */
struct vxlan_dev {
122 123 124
	struct hlist_node hlist;	/* vni hash table */
	struct list_head  next;		/* vxlan's per namespace list */
	struct vxlan_sock *vn_sock;	/* listening socket */
S
stephen hemminger 已提交
125
	struct net_device *dev;
126
	struct vxlan_rdst default_dst;	/* default destination */
S
stephen hemminger 已提交
127
	__be32		  saddr;	/* source address */
128
	__be16		  dst_port;
129 130
	__u16		  port_min;	/* source port range */
	__u16		  port_max;
S
stephen hemminger 已提交
131 132
	__u8		  tos;		/* TOS override */
	__u8		  ttl;
D
David Stevens 已提交
133
	u32		  flags;	/* VXLAN_F_* below */
S
stephen hemminger 已提交
134

135
	struct work_struct sock_work;
136
	struct work_struct igmp_work;
137

S
stephen hemminger 已提交
138 139 140 141 142 143 144 145 146
	unsigned long	  age_interval;
	struct timer_list age_timer;
	spinlock_t	  hash_lock;
	unsigned int	  addrcnt;
	unsigned int	  addrmax;

	struct hlist_head fdb_head[FDB_HASH_SIZE];
};

D
David Stevens 已提交
147 148 149 150 151 152
#define VXLAN_F_LEARN	0x01
#define VXLAN_F_PROXY	0x02
#define VXLAN_F_RSC	0x04
#define VXLAN_F_L2MISS	0x08
#define VXLAN_F_L3MISS	0x10

S
stephen hemminger 已提交
153 154
/* salt for hash table */
static u32 vxlan_salt __read_mostly;
155
static struct workqueue_struct *vxlan_wq;
S
stephen hemminger 已提交
156

157 158
static void vxlan_sock_work(struct work_struct *work);

159 160 161 162 163 164 165 166
/* Virtual Network hash table head */
static inline struct hlist_head *vni_head(struct vxlan_sock *vs, u32 id)
{
	return &vs->vni_list[hash_32(id, VNI_HASH_BITS)];
}

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

170 171 172 173 174 175 176 177 178 179 180 181 182
	return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
}

/* Find VXLAN socket based on network namespace and UDP port */
static struct vxlan_sock *vxlan_find_port(struct net *net, __be16 port)
{
	struct vxlan_sock *vs;

	hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {
		if (inet_sk(vs->sock->sk)->inet_sport == port)
			return vs;
	}
	return NULL;
S
stephen hemminger 已提交
183 184 185
}

/* Look up VNI in a per net namespace table */
186
static struct vxlan_dev *vxlan_find_vni(struct net *net, u32 id, __be16 port)
S
stephen hemminger 已提交
187
{
188
	struct vxlan_sock *vs;
S
stephen hemminger 已提交
189 190
	struct vxlan_dev *vxlan;

191 192 193 194 195
	vs = vxlan_find_port(net, port);
	if (!vs)
		return NULL;

	hlist_for_each_entry_rcu(vxlan, vni_head(vs, id), hlist) {
196
		if (vxlan->default_dst.remote_vni == id)
S
stephen hemminger 已提交
197 198 199 200 201 202 203 204 205
			return vxlan;
	}

	return NULL;
}

/* Fill in neighbour message in skbuff. */
static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,
			   const struct vxlan_fdb *fdb,
206 207
			   u32 portid, u32 seq, int type, unsigned int flags,
			   const struct vxlan_rdst *rdst)
S
stephen hemminger 已提交
208 209 210 211 212
{
	unsigned long now = jiffies;
	struct nda_cacheinfo ci;
	struct nlmsghdr *nlh;
	struct ndmsg *ndm;
D
David Stevens 已提交
213
	bool send_ip, send_eth;
S
stephen hemminger 已提交
214 215 216 217 218 219 220

	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 已提交
221 222 223 224 225

	send_eth = send_ip = true;

	if (type == RTM_GETNEIGH) {
		ndm->ndm_family	= AF_INET;
226
		send_ip = rdst->remote_ip != htonl(INADDR_ANY);
D
David Stevens 已提交
227 228 229
		send_eth = !is_zero_ether_addr(fdb->eth_addr);
	} else
		ndm->ndm_family	= AF_BRIDGE;
S
stephen hemminger 已提交
230 231
	ndm->ndm_state = fdb->state;
	ndm->ndm_ifindex = vxlan->dev->ifindex;
232
	ndm->ndm_flags = fdb->flags;
S
stephen hemminger 已提交
233 234
	ndm->ndm_type = NDA_DST;

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

238 239 240
	if (send_ip && nla_put_be32(skb, NDA_DST, rdst->remote_ip))
		goto nla_put_failure;

241
	if (rdst->remote_port && rdst->remote_port != vxlan->dst_port &&
242 243
	    nla_put_be16(skb, NDA_PORT, rdst->remote_port))
		goto nla_put_failure;
244
	if (rdst->remote_vni != vxlan->default_dst.remote_vni &&
245 246 247 248
	    nla_put_be32(skb, NDA_VNI, rdst->remote_vni))
		goto nla_put_failure;
	if (rdst->remote_ifindex &&
	    nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
S
stephen hemminger 已提交
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
		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;

	return nlmsg_end(skb, nlh);

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 */
		+ nla_total_size(sizeof(__be32)) /* NDA_DST */
271
		+ nla_total_size(sizeof(__be16)) /* NDA_PORT */
272 273
		+ nla_total_size(sizeof(__be32)) /* NDA_VNI */
		+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
S
stephen hemminger 已提交
274 275 276 277 278 279 280 281 282 283 284 285 286 287
		+ nla_total_size(sizeof(struct nda_cacheinfo));
}

static void vxlan_fdb_notify(struct vxlan_dev *vxlan,
			     const struct vxlan_fdb *fdb, int type)
{
	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;

288
	err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0, &fdb->remote);
S
stephen hemminger 已提交
289 290 291 292 293 294 295 296 297 298 299 300 301 302
	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);
}

D
David Stevens 已提交
303 304 305 306 307 308 309
static void vxlan_ip_miss(struct net_device *dev, __be32 ipa)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb f;

	memset(&f, 0, sizeof f);
	f.state = NUD_STALE;
310 311
	f.remote.remote_ip = ipa; /* goes to NDA_DST */
	f.remote.remote_vni = VXLAN_N_VID;
D
David Stevens 已提交
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326

	vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
}

static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])
{
	struct vxlan_fdb	f;

	memset(&f, 0, sizeof f);
	f.state = NUD_STALE;
	memcpy(f.eth_addr, eth_addr, ETH_ALEN);

	vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
}

S
stephen hemminger 已提交
327 328 329 330 331 332 333 334
/* 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;
335 336
#else
	value <<= 16;
S
stephen hemminger 已提交
337 338 339 340 341 342 343 344 345 346 347 348
#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 */
349
static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,
S
stephen hemminger 已提交
350 351 352 353 354 355
					const u8 *mac)

{
	struct hlist_head *head = vxlan_fdb_head(vxlan, mac);
	struct vxlan_fdb *f;

356
	hlist_for_each_entry_rcu(f, head, hlist) {
S
stephen hemminger 已提交
357 358 359 360 361 362 363
		if (compare_ether_addr(mac, f->eth_addr) == 0)
			return f;
	}

	return NULL;
}

364 365 366 367 368 369 370 371 372 373 374 375
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;
}

376 377
/* Add/update destinations for multicast */
static int vxlan_fdb_append(struct vxlan_fdb *f,
378
			    __be32 ip, __be16 port, __u32 vni, __u32 ifindex)
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
{
	struct vxlan_rdst *rd_prev, *rd;

	rd_prev = NULL;
	for (rd = &f->remote; rd; rd = rd->remote_next) {
		if (rd->remote_ip == ip &&
		    rd->remote_port == port &&
		    rd->remote_vni == vni &&
		    rd->remote_ifindex == ifindex)
			return 0;
		rd_prev = rd;
	}
	rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
	if (rd == NULL)
		return -ENOBUFS;
	rd->remote_ip = ip;
	rd->remote_port = port;
	rd->remote_vni = vni;
	rd->remote_ifindex = ifindex;
	rd->remote_next = NULL;
	rd_prev->remote_next = rd;
	return 1;
}

S
stephen hemminger 已提交
403 404 405
/* Add new entry to forwarding table -- assumes lock held */
static int vxlan_fdb_create(struct vxlan_dev *vxlan,
			    const u8 *mac, __be32 ip,
406
			    __u16 state, __u16 flags,
407
			    __be16 port, __u32 vni, __u32 ifindex,
408
			    __u8 ndm_flags)
S
stephen hemminger 已提交
409 410 411 412
{
	struct vxlan_fdb *f;
	int notify = 0;

413
	f = __vxlan_find_mac(vxlan, mac);
S
stephen hemminger 已提交
414 415 416 417 418 419 420 421 422 423 424
	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;
		}
425 426 427 428 429
		if (f->flags != ndm_flags) {
			f->flags = ndm_flags;
			f->updated = jiffies;
			notify = 1;
		}
430 431 432 433 434 435 436 437
		if ((flags & NLM_F_APPEND) &&
		    is_multicast_ether_addr(f->eth_addr)) {
			int rc = vxlan_fdb_append(f, ip, port, vni, ifindex);

			if (rc < 0)
				return rc;
			notify |= rc;
		}
S
stephen hemminger 已提交
438 439 440 441 442 443 444 445 446 447 448 449 450
	} else {
		if (!(flags & NLM_F_CREATE))
			return -ENOENT;

		if (vxlan->addrmax && vxlan->addrcnt >= vxlan->addrmax)
			return -ENOSPC;

		netdev_dbg(vxlan->dev, "add %pM -> %pI4\n", mac, &ip);
		f = kmalloc(sizeof(*f), GFP_ATOMIC);
		if (!f)
			return -ENOMEM;

		notify = 1;
451 452 453 454 455
		f->remote.remote_ip = ip;
		f->remote.remote_port = port;
		f->remote.remote_vni = vni;
		f->remote.remote_ifindex = ifindex;
		f->remote.remote_next = NULL;
S
stephen hemminger 已提交
456
		f->state = state;
457
		f->flags = ndm_flags;
S
stephen hemminger 已提交
458 459 460 461 462 463 464 465 466 467 468 469 470 471
		f->updated = f->used = jiffies;
		memcpy(f->eth_addr, mac, ETH_ALEN);

		++vxlan->addrcnt;
		hlist_add_head_rcu(&f->hlist,
				   vxlan_fdb_head(vxlan, mac));
	}

	if (notify)
		vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);

	return 0;
}

W
Wei Yongjun 已提交
472
static void vxlan_fdb_free(struct rcu_head *head)
473 474 475 476 477 478 479 480 481 482 483 484
{
	struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);

	while (f->remote.remote_next) {
		struct vxlan_rdst *rd = f->remote.remote_next;

		f->remote.remote_next = rd->remote_next;
		kfree(rd);
	}
	kfree(f);
}

S
stephen hemminger 已提交
485 486 487 488 489 490 491 492 493
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;
	vxlan_fdb_notify(vxlan, f, RTM_DELNEIGH);

	hlist_del_rcu(&f->hlist);
494
	call_rcu(&f->rcu, vxlan_fdb_free);
S
stephen hemminger 已提交
495 496 497 498 499 500 501 502
}

/* Add static entry (via netlink) */
static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
			 struct net_device *dev,
			 const unsigned char *addr, u16 flags)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
503
	struct net *net = dev_net(vxlan->dev);
S
stephen hemminger 已提交
504
	__be32 ip;
505 506
	__be16 port;
	u32 vni, ifindex;
S
stephen hemminger 已提交
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
	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;

	if (nla_len(tb[NDA_DST]) != sizeof(__be32))
		return -EAFNOSUPPORT;

	ip = nla_get_be32(tb[NDA_DST]);

523
	if (tb[NDA_PORT]) {
524
		if (nla_len(tb[NDA_PORT]) != sizeof(__be16))
525
			return -EINVAL;
526
		port = nla_get_be16(tb[NDA_PORT]);
527
	} else
528
		port = vxlan->dst_port;
529 530 531 532 533 534

	if (tb[NDA_VNI]) {
		if (nla_len(tb[NDA_VNI]) != sizeof(u32))
			return -EINVAL;
		vni = nla_get_u32(tb[NDA_VNI]);
	} else
535
		vni = vxlan->default_dst.remote_vni;
536 537

	if (tb[NDA_IFINDEX]) {
P
Pravin B Shelar 已提交
538
		struct net_device *tdev;
539 540 541 542

		if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
			return -EINVAL;
		ifindex = nla_get_u32(tb[NDA_IFINDEX]);
P
Pravin B Shelar 已提交
543 544
		tdev = dev_get_by_index(net, ifindex);
		if (!tdev)
545
			return -EADDRNOTAVAIL;
P
Pravin B Shelar 已提交
546
		dev_put(tdev);
547 548 549
	} else
		ifindex = 0;

S
stephen hemminger 已提交
550
	spin_lock_bh(&vxlan->hash_lock);
551 552
	err = vxlan_fdb_create(vxlan, addr, ip, ndm->ndm_state, flags,
			       port, vni, ifindex, ndm->ndm_flags);
S
stephen hemminger 已提交
553 554 555 556 557 558
	spin_unlock_bh(&vxlan->hash_lock);

	return err;
}

/* Delete entry (via netlink) */
559 560
static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
			    struct net_device *dev,
S
stephen hemminger 已提交
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
			    const unsigned char *addr)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb *f;
	int err = -ENOENT;

	spin_lock_bh(&vxlan->hash_lock);
	f = vxlan_find_mac(vxlan, addr);
	if (f) {
		vxlan_fdb_destroy(vxlan, f);
		err = 0;
	}
	spin_unlock_bh(&vxlan->hash_lock);

	return err;
}

/* Dump forwarding table */
static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
			  struct net_device *dev, int idx)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	unsigned int h;

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

589
		hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
590 591 592 593 594 595 596 597 598 599 600 601
			struct vxlan_rdst *rd;
			for (rd = &f->remote; rd; rd = rd->remote_next) {
				if (idx < cb->args[0])
					goto skip;

				err = vxlan_fdb_info(skb, vxlan, f,
						     NETLINK_CB(cb->skb).portid,
						     cb->nlh->nlmsg_seq,
						     RTM_NEWNEIGH,
						     NLM_F_MULTI, rd);
				if (err < 0)
					break;
S
stephen hemminger 已提交
602
skip:
603 604
				++idx;
			}
S
stephen hemminger 已提交
605 606 607 608 609 610 611 612
		}
	}

	return idx;
}

/* Watch incoming packets to learn mapping between Ethernet address
 * and Tunnel endpoint.
613
 * Return true if packet is bogus and should be droppped.
S
stephen hemminger 已提交
614
 */
615
static bool vxlan_snoop(struct net_device *dev,
S
stephen hemminger 已提交
616 617 618 619 620 621 622
			__be32 src_ip, const u8 *src_mac)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb *f;

	f = vxlan_find_mac(vxlan, src_mac);
	if (likely(f)) {
623
		if (likely(f->remote.remote_ip == src_ip))
624 625 626
			return false;

		/* Don't migrate static entries, drop packets */
627
		if (f->state & NUD_NOARP)
628
			return true;
S
stephen hemminger 已提交
629 630 631 632

		if (net_ratelimit())
			netdev_info(dev,
				    "%pM migrated from %pI4 to %pI4\n",
633
				    src_mac, &f->remote.remote_ip, &src_ip);
S
stephen hemminger 已提交
634

635
		f->remote.remote_ip = src_ip;
S
stephen hemminger 已提交
636
		f->updated = jiffies;
637
		vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);
S
stephen hemminger 已提交
638 639 640
	} else {
		/* learned new entry */
		spin_lock(&vxlan->hash_lock);
641 642 643 644 645 646 647 648 649

		/* 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,
					 vxlan->dst_port,
					 vxlan->default_dst.remote_vni,
					 0, NTF_SELF);
S
stephen hemminger 已提交
650 651
		spin_unlock(&vxlan->hash_lock);
	}
652 653

	return false;
S
stephen hemminger 已提交
654 655 656 657
}


/* See if multicast group is already in use by other ID */
658
static bool vxlan_group_used(struct vxlan_net *vn, __be32 remote_ip)
S
stephen hemminger 已提交
659
{
660
	struct vxlan_dev *vxlan;
S
stephen hemminger 已提交
661

662 663 664
	list_for_each_entry(vxlan, &vn->vxlan_list, next) {
		if (!netif_running(vxlan->dev))
			continue;
S
stephen hemminger 已提交
665

666
		if (vxlan->default_dst.remote_ip == remote_ip)
667 668
			return true;
	}
S
stephen hemminger 已提交
669 670 671 672

	return false;
}

673
static void vxlan_sock_hold(struct vxlan_sock *vs)
S
stephen hemminger 已提交
674
{
675 676
	atomic_inc(&vs->refcnt);
}
S
stephen hemminger 已提交
677

678
static void vxlan_sock_release(struct vxlan_net *vn, struct vxlan_sock *vs)
679 680 681
{
	if (!atomic_dec_and_test(&vs->refcnt))
		return;
S
stephen hemminger 已提交
682

683
	spin_lock(&vn->sock_lock);
684
	hlist_del_rcu(&vs->hlist);
685 686
	spin_unlock(&vn->sock_lock);

687
	queue_work(vxlan_wq, &vs->del_work);
S
stephen hemminger 已提交
688 689
}

690 691 692 693
/* Callback to update multicast group membership.
 * Scheduled when vxlan goes up/down.
 */
static void vxlan_igmp_work(struct work_struct *work)
S
stephen hemminger 已提交
694
{
695 696 697 698
	struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_work);
	struct vxlan_net *vn = net_generic(dev_net(vxlan->dev), vxlan_net_id);
	struct vxlan_sock *vs = vxlan->vn_sock;
	struct sock *sk = vs->sock->sk;
S
stephen hemminger 已提交
699
	struct ip_mreqn mreq = {
700 701
		.imr_multiaddr.s_addr	= vxlan->default_dst.remote_ip,
		.imr_ifindex		= vxlan->default_dst.remote_ifindex,
S
stephen hemminger 已提交
702 703 704
	};

	lock_sock(sk);
705 706 707 708
	if (vxlan_group_used(vn, vxlan->default_dst.remote_ip))
		ip_mc_join_group(sk, &mreq);
	else
		ip_mc_leave_group(sk, &mreq);
S
stephen hemminger 已提交
709 710
	release_sock(sk);

711
	vxlan_sock_release(vn, vs);
712
	dev_put(vxlan->dev);
S
stephen hemminger 已提交
713 714 715 716 717 718 719 720
}

/* Callback from net/ipv4/udp.c to receive packets */
static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
{
	struct iphdr *oip;
	struct vxlanhdr *vxh;
	struct vxlan_dev *vxlan;
721
	struct pcpu_tstats *stats;
722
	__be16 port;
S
stephen hemminger 已提交
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
	__u32 vni;
	int err;

	/* pop off outer UDP header */
	__skb_pull(skb, sizeof(struct udphdr));

	/* Need Vxlan and inner Ethernet header to be present */
	if (!pskb_may_pull(skb, sizeof(struct vxlanhdr)))
		goto error;

	/* Drop packets with reserved bits set */
	vxh = (struct vxlanhdr *) skb->data;
	if (vxh->vx_flags != htonl(VXLAN_FLAGS) ||
	    (vxh->vx_vni & htonl(0xff))) {
		netdev_dbg(skb->dev, "invalid vxlan flags=%#x vni=%#x\n",
			   ntohl(vxh->vx_flags), ntohl(vxh->vx_vni));
		goto error;
	}

	__skb_pull(skb, sizeof(struct vxlanhdr));

	/* Is this VNI defined? */
	vni = ntohl(vxh->vx_vni) >> 8;
746 747
	port = inet_sk(sk)->inet_sport;
	vxlan = vxlan_find_vni(sock_net(sk), vni, port);
S
stephen hemminger 已提交
748
	if (!vxlan) {
749 750
		netdev_dbg(skb->dev, "unknown vni %d port %u\n",
			   vni, ntohs(port));
S
stephen hemminger 已提交
751 752 753 754 755 756 757 758 759
		goto drop;
	}

	if (!pskb_may_pull(skb, ETH_HLEN)) {
		vxlan->dev->stats.rx_length_errors++;
		vxlan->dev->stats.rx_errors++;
		goto drop;
	}

D
David Stevens 已提交
760 761
	skb_reset_mac_header(skb);

S
stephen hemminger 已提交
762 763 764 765 766 767 768 769 770
	/* Re-examine inner Ethernet packet */
	oip = ip_hdr(skb);
	skb->protocol = eth_type_trans(skb, vxlan->dev);

	/* Ignore packet loops (and multicast echo) */
	if (compare_ether_addr(eth_hdr(skb)->h_source,
			       vxlan->dev->dev_addr) == 0)
		goto drop;

771 772 773
	if ((vxlan->flags & VXLAN_F_LEARN) &&
	    vxlan_snoop(skb->dev, oip->saddr, eth_hdr(skb)->h_source))
		goto drop;
S
stephen hemminger 已提交
774 775 776

	__skb_tunnel_rx(skb, vxlan->dev);
	skb_reset_network_header(skb);
777 778 779 780 781 782 783 784 785 786 787

	/* If the NIC driver gave us an encapsulated packet with
	 * CHECKSUM_UNNECESSARY and Rx checksum feature is enabled,
	 * leave the CHECKSUM_UNNECESSARY, the device checksummed it
	 * for us. Otherwise force the upper layers to verify it.
	 */
	if (skb->ip_summed != CHECKSUM_UNNECESSARY || !skb->encapsulation ||
	    !(vxlan->dev->features & NETIF_F_RXCSUM))
		skb->ip_summed = CHECKSUM_NONE;

	skb->encapsulation = 0;
S
stephen hemminger 已提交
788 789 790 791 792 793 794 795 796 797 798 799 800

	err = IP_ECN_decapsulate(oip, skb);
	if (unlikely(err)) {
		if (log_ecn_error)
			net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
					     &oip->saddr, oip->tos);
		if (err > 1) {
			++vxlan->dev->stats.rx_frame_errors;
			++vxlan->dev->stats.rx_errors;
			goto drop;
		}
	}

801
	stats = this_cpu_ptr(vxlan->dev->tstats);
S
stephen hemminger 已提交
802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
	u64_stats_update_begin(&stats->syncp);
	stats->rx_packets++;
	stats->rx_bytes += skb->len;
	u64_stats_update_end(&stats->syncp);

	netif_rx(skb);

	return 0;
error:
	/* Put UDP header back */
	__skb_push(skb, sizeof(struct udphdr));

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

D
David Stevens 已提交
821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
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);
869
		if (f && f->remote.remote_ip == htonl(INADDR_ANY)) {
D
David Stevens 已提交
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
			/* 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);

		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++;
	} else if (vxlan->flags & VXLAN_F_L3MISS)
		vxlan_ip_miss(dev, tip);
out:
	consume_skb(skb);
	return NETDEV_TX_OK;
}

static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct neighbour *n;
	struct iphdr *pip;

	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:
		if (!pskb_may_pull(skb, sizeof(struct iphdr)))
			return false;
		pip = ip_hdr(skb);
		n = neigh_lookup(&arp_tbl, &pip->daddr, dev);
		break;
	default:
		return false;
	}

	if (n) {
		bool diff;

		diff = compare_ether_addr(eth_hdr(skb)->h_dest, n->ha) != 0;
		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;
	} else if (vxlan->flags & VXLAN_F_L3MISS)
		vxlan_ip_miss(dev, pip->daddr);
	return false;
}

931
static void vxlan_sock_put(struct sk_buff *skb)
932 933 934 935 936 937 938
{
	sock_put(skb->sk);
}

/* On transmit, associate with the tunnel socket */
static void vxlan_set_owner(struct net_device *dev, struct sk_buff *skb)
{
939 940
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct sock *sk = vxlan->vn_sock->sock->sk;
941 942 943 944

	skb_orphan(skb);
	sock_hold(sk);
	skb->sk = sk;
945
	skb->destructor = vxlan_sock_put;
946 947
}

948 949 950 951 952
/* Compute source port for outgoing packet
 *   first choice to use L4 flow hash since it will spread
 *     better and maybe available from hardware
 *   secondary choice is to use jhash on the Ethernet header
 */
953
static __be16 vxlan_src_port(const struct vxlan_dev *vxlan, struct sk_buff *skb)
954 955 956 957 958 959 960 961 962
{
	unsigned int range = (vxlan->port_max - vxlan->port_min) + 1;
	u32 hash;

	hash = skb_get_rxhash(skb);
	if (!hash)
		hash = jhash(skb->data, 2 * ETH_ALEN,
			     (__force u32) skb->protocol);

963
	return htons((((u64) hash * range) >> 32) + vxlan->port_min);
964 965
}

966 967 968 969 970 971 972
static int handle_offloads(struct sk_buff *skb)
{
	if (skb_is_gso(skb)) {
		int err = skb_unclone(skb, GFP_ATOMIC);
		if (unlikely(err))
			return err;

D
Dmitry Kravkov 已提交
973
		skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
974 975 976 977 978 979
	} else if (skb->ip_summed != CHECKSUM_PARTIAL)
		skb->ip_summed = CHECKSUM_NONE;

	return 0;
}

980 981 982 983 984 985 986 987 988 989 990 991 992
/* 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)
{
	struct pcpu_tstats *tx_stats = this_cpu_ptr(src_vxlan->dev->tstats);
	struct pcpu_tstats *rx_stats = this_cpu_ptr(dst_vxlan->dev->tstats);

	skb->pkt_type = PACKET_HOST;
	skb->encapsulation = 0;
	skb->dev = dst_vxlan->dev;
	__skb_pull(skb, skb_network_offset(skb));

	if (dst_vxlan->flags & VXLAN_F_LEARN)
993 994
		vxlan_snoop(skb->dev, htonl(INADDR_LOOPBACK),
			    eth_hdr(skb)->h_source);
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010

	u64_stats_update_begin(&tx_stats->syncp);
	tx_stats->tx_packets++;
	tx_stats->tx_bytes += skb->len;
	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++;
		rx_stats->rx_bytes += skb->len;
		u64_stats_update_end(&rx_stats->syncp);
	} else {
		skb->dev->stats.rx_dropped++;
	}
}

1011 1012
static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
			   struct vxlan_rdst *rdst, bool did_rsc)
S
stephen hemminger 已提交
1013 1014 1015 1016 1017 1018 1019 1020
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct rtable *rt;
	const struct iphdr *old_iph;
	struct vxlanhdr *vxh;
	struct udphdr *uh;
	struct flowi4 fl4;
	__be32 dst;
1021
	__be16 src_port, dst_port;
1022
        u32 vni;
S
stephen hemminger 已提交
1023 1024
	__be16 df = 0;
	__u8 tos, ttl;
1025
	int err;
S
stephen hemminger 已提交
1026

1027
	dst_port = rdst->remote_port ? rdst->remote_port : vxlan->dst_port;
1028 1029
	vni = rdst->remote_vni;
	dst = rdst->remote_ip;
D
David Stevens 已提交
1030 1031 1032 1033

	if (!dst) {
		if (did_rsc) {
			/* short-circuited back to local bridge */
1034
			vxlan_encap_bypass(skb, vxlan, vxlan);
1035
			return;
D
David Stevens 已提交
1036
		}
1037
		goto drop;
D
David Stevens 已提交
1038
	}
1039

1040 1041 1042 1043 1044
	if (!skb->encapsulation) {
		skb_reset_inner_headers(skb);
		skb->encapsulation = 1;
	}

S
stephen hemminger 已提交
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
	/* Need space for new headers (invalidates iph ptr) */
	if (skb_cow_head(skb, VXLAN_HEADROOM))
		goto drop;

	old_iph = ip_hdr(skb);

	ttl = vxlan->ttl;
	if (!ttl && IN_MULTICAST(ntohl(dst)))
		ttl = 1;

	tos = vxlan->tos;
	if (tos == 1)
1057
		tos = ip_tunnel_get_dsfield(old_iph, skb);
S
stephen hemminger 已提交
1058

1059
	src_port = vxlan_src_port(vxlan, skb);
S
stephen hemminger 已提交
1060

S
stephen hemminger 已提交
1061
	memset(&fl4, 0, sizeof(fl4));
1062
	fl4.flowi4_oif = rdst->remote_ifindex;
S
stephen hemminger 已提交
1063 1064 1065 1066 1067
	fl4.flowi4_tos = RT_TOS(tos);
	fl4.daddr = dst;
	fl4.saddr = vxlan->saddr;

	rt = ip_route_output_key(dev_net(dev), &fl4);
S
stephen hemminger 已提交
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
	if (IS_ERR(rt)) {
		netdev_dbg(dev, "no route to %pI4\n", &dst);
		dev->stats.tx_carrier_errors++;
		goto tx_error;
	}

	if (rt->dst.dev == dev) {
		netdev_dbg(dev, "circular route to %pI4\n", &dst);
		ip_rt_put(rt);
		dev->stats.collisions++;
		goto tx_error;
	}

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

		ip_rt_put(rt);
1087
		dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);
1088 1089 1090
		if (!dst_vxlan)
			goto tx_error;
		vxlan_encap_bypass(skb, vxlan, dst_vxlan);
1091
		return;
1092
	}
S
stephen hemminger 已提交
1093 1094
	vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
	vxh->vx_flags = htonl(VXLAN_FLAGS);
1095
	vxh->vx_vni = htonl(vni << 8);
S
stephen hemminger 已提交
1096 1097 1098 1099 1100

	__skb_push(skb, sizeof(*uh));
	skb_reset_transport_header(skb);
	uh = udp_hdr(skb);

1101
	uh->dest = dst_port;
1102
	uh->source = src_port;
S
stephen hemminger 已提交
1103 1104 1105 1106

	uh->len = htons(skb->len);
	uh->check = 0;

1107 1108
	vxlan_set_owner(dev, skb);

1109 1110
	if (handle_offloads(skb))
		goto drop;
S
stephen hemminger 已提交
1111

1112 1113 1114 1115 1116 1117 1118
	tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
	ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);

	err = iptunnel_xmit(dev_net(dev), rt, skb, fl4.saddr, dst,
			    IPPROTO_UDP, tos, ttl, df);
	iptunnel_xmit_stats(err, &dev->stats, dev->tstats);

1119
	return;
S
stephen hemminger 已提交
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130

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

tx_error:
	dev->stats.tx_errors++;
tx_free:
	dev_kfree_skb(skb);
}

1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
/* 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);
	struct ethhdr *eth;
	bool did_rsc = false;
1142
	struct vxlan_rdst *rdst0, *rdst;
1143 1144 1145 1146 1147 1148 1149 1150 1151
	struct vxlan_fdb *f;

	skb_reset_mac_header(skb);
	eth = eth_hdr(skb);

	if ((vxlan->flags & VXLAN_F_PROXY) && ntohs(eth->h_proto) == ETH_P_ARP)
		return arp_reduce(dev, skb);

	f = vxlan_find_mac(vxlan, eth->h_dest);
1152 1153 1154 1155 1156 1157 1158 1159 1160
	did_rsc = false;

	if (f && (f->flags & NTF_ROUTER) && (vxlan->flags & VXLAN_F_RSC) &&
	    ntohs(eth->h_proto) == ETH_P_IP) {
		did_rsc = route_shortcircuit(dev, skb);
		if (did_rsc)
			f = vxlan_find_mac(vxlan, eth->h_dest);
	}

1161
	if (f == NULL) {
1162 1163 1164
		rdst0 = &vxlan->default_dst;

		if (rdst0->remote_ip == htonl(INADDR_ANY) &&
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
		    (vxlan->flags & VXLAN_F_L2MISS) &&
		    !is_multicast_ether_addr(eth->h_dest))
			vxlan_fdb_miss(vxlan, eth->h_dest);
	} else
		rdst0 = &f->remote;


	/* if there are multiple destinations, send copies */
	for (rdst = rdst0->remote_next; rdst; rdst = rdst->remote_next) {
		struct sk_buff *skb1;

		skb1 = skb_clone(skb, GFP_ATOMIC);
1177 1178
		if (skb1)
			vxlan_xmit_one(skb1, dev, rdst, did_rsc);
1179 1180
	}

1181 1182
	vxlan_xmit_one(skb, dev, rdst0, did_rsc);
	return NETDEV_TX_OK;
1183 1184
}

S
stephen hemminger 已提交
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
/* 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;

	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);
			unsigned long timeout;

1203
			if (f->state & NUD_PERMANENT)
S
stephen hemminger 已提交
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
				continue;

			timeout = f->used + vxlan->age_interval * HZ;
			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;
		}
	}
	spin_unlock_bh(&vxlan->hash_lock);

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

/* Setup stats when device is created */
static int vxlan_init(struct net_device *dev)
{
1225 1226 1227 1228 1229
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
	struct vxlan_sock *vs;
	__u32 vni = vxlan->default_dst.remote_vni;

1230 1231
	dev->tstats = alloc_percpu(struct pcpu_tstats);
	if (!dev->tstats)
S
stephen hemminger 已提交
1232 1233
		return -ENOMEM;

1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247
	spin_lock(&vn->sock_lock);
	vs = vxlan_find_port(dev_net(dev), vxlan->dst_port);
	if (vs) {
		/* If we have a socket with same port already, reuse it */
		atomic_inc(&vs->refcnt);
		vxlan->vn_sock = vs;
		hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));
	} else {
		/* otherwise make new socket outside of RTNL */
		dev_hold(dev);
		queue_work(vxlan_wq, &vxlan->sock_work);
	}
	spin_unlock(&vn->sock_lock);

S
stephen hemminger 已提交
1248 1249 1250
	return 0;
}

1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
static void vxlan_uninit(struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
	struct vxlan_sock *vs = vxlan->vn_sock;

	if (vs)
		vxlan_sock_release(vn, vs);
	free_percpu(dev->tstats);
}

S
stephen hemminger 已提交
1262 1263 1264 1265
/* 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);
1266 1267 1268 1269 1270
	struct vxlan_sock *vs = vxlan->vn_sock;

	/* socket hasn't been created */
	if (!vs)
		return -ENOTCONN;
S
stephen hemminger 已提交
1271

1272
	if (IN_MULTICAST(ntohl(vxlan->default_dst.remote_ip))) {
1273
		vxlan_sock_hold(vs);
1274 1275
		dev_hold(dev);
		queue_work(vxlan_wq, &vxlan->igmp_work);
S
stephen hemminger 已提交
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
	}

	if (vxlan->age_interval)
		mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);

	return 0;
}

/* Purge the forwarding table */
static void vxlan_flush(struct vxlan_dev *vxlan)
{
1287
	unsigned int h;
S
stephen hemminger 已提交
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304

	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);
			vxlan_fdb_destroy(vxlan, f);
		}
	}
	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);
1305
	struct vxlan_sock *vs = vxlan->vn_sock;
S
stephen hemminger 已提交
1306

1307 1308
	if (vs && IN_MULTICAST(ntohl(vxlan->default_dst.remote_ip))) {
		vxlan_sock_hold(vs);
1309 1310 1311
		dev_hold(dev);
		queue_work(vxlan_wq, &vxlan->igmp_work);
	}
S
stephen hemminger 已提交
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326

	del_timer_sync(&vxlan->age_timer);

	vxlan_flush(vxlan);

	return 0;
}

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

static const struct net_device_ops vxlan_netdev_ops = {
	.ndo_init		= vxlan_init,
1327
	.ndo_uninit		= vxlan_uninit,
S
stephen hemminger 已提交
1328 1329 1330
	.ndo_open		= vxlan_open,
	.ndo_stop		= vxlan_stop,
	.ndo_start_xmit		= vxlan_xmit,
1331
	.ndo_get_stats64	= ip_tunnel_get_stats64,
S
stephen hemminger 已提交
1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
	.ndo_set_rx_mode	= vxlan_set_multicast_list,
	.ndo_change_mtu		= eth_change_mtu,
	.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,
};

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

/* Initialize the device structure. */
static void vxlan_setup(struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
1350
	unsigned int h;
1351
	int low, high;
S
stephen hemminger 已提交
1352 1353 1354

	eth_hw_addr_random(dev);
	ether_setup(dev);
S
stephen hemminger 已提交
1355
	dev->hard_header_len = ETH_HLEN + VXLAN_HEADROOM;
S
stephen hemminger 已提交
1356 1357

	dev->netdev_ops = &vxlan_netdev_ops;
1358
	dev->destructor = free_netdev;
S
stephen hemminger 已提交
1359 1360 1361 1362 1363
	SET_NETDEV_DEVTYPE(dev, &vxlan_type);

	dev->tx_queue_len = 0;
	dev->features	|= NETIF_F_LLTX;
	dev->features	|= NETIF_F_NETNS_LOCAL;
1364
	dev->features	|= NETIF_F_SG | NETIF_F_HW_CSUM;
1365
	dev->features   |= NETIF_F_RXCSUM;
1366
	dev->features   |= NETIF_F_GSO_SOFTWARE;
1367 1368

	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1369
	dev->hw_features |= NETIF_F_GSO_SOFTWARE;
S
stephen hemminger 已提交
1370
	dev->priv_flags	&= ~IFF_XMIT_DST_RELEASE;
1371
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
S
stephen hemminger 已提交
1372

1373
	INIT_LIST_HEAD(&vxlan->next);
S
stephen hemminger 已提交
1374
	spin_lock_init(&vxlan->hash_lock);
1375
	INIT_WORK(&vxlan->igmp_work, vxlan_igmp_work);
1376
	INIT_WORK(&vxlan->sock_work, vxlan_sock_work);
S
stephen hemminger 已提交
1377 1378 1379 1380 1381

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

1382 1383 1384
	inet_get_local_port_range(&low, &high);
	vxlan->port_min = low;
	vxlan->port_max = high;
1385
	vxlan->dst_port = htons(vxlan_port);
1386

S
stephen hemminger 已提交
1387 1388 1389 1390 1391 1392 1393 1394
	vxlan->dev = dev;

	for (h = 0; h < FDB_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&vxlan->fdb_head[h]);
}

static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
	[IFLA_VXLAN_ID]		= { .type = NLA_U32 },
1395
	[IFLA_VXLAN_GROUP]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
S
stephen hemminger 已提交
1396 1397 1398 1399 1400 1401 1402
	[IFLA_VXLAN_LINK]	= { .type = NLA_U32 },
	[IFLA_VXLAN_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
	[IFLA_VXLAN_TOS]	= { .type = NLA_U8 },
	[IFLA_VXLAN_TTL]	= { .type = NLA_U8 },
	[IFLA_VXLAN_LEARNING]	= { .type = NLA_U8 },
	[IFLA_VXLAN_AGEING]	= { .type = NLA_U32 },
	[IFLA_VXLAN_LIMIT]	= { .type = NLA_U32 },
1403
	[IFLA_VXLAN_PORT_RANGE] = { .len  = sizeof(struct ifla_vxlan_port_range) },
D
David Stevens 已提交
1404 1405 1406 1407
	[IFLA_VXLAN_PROXY]	= { .type = NLA_U8 },
	[IFLA_VXLAN_RSC]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L2MISS]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L3MISS]	= { .type = NLA_U8 },
1408
	[IFLA_VXLAN_PORT]	= { .type = NLA_U16 },
S
stephen hemminger 已提交
1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
};

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

1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
	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 已提交
1445 1446 1447
	return 0;
}

Y
Yan Burman 已提交
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
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,
};

1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
static void vxlan_del_work(struct work_struct *work)
{
	struct vxlan_sock *vs = container_of(work, struct vxlan_sock, del_work);

	sk_release_kernel(vs->sock->sk);
	kfree_rcu(vs, rcu);
}

static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port)
{
	struct vxlan_sock *vs;
	struct sock *sk;
	struct sockaddr_in vxlan_addr = {
		.sin_family = AF_INET,
		.sin_addr.s_addr = htonl(INADDR_ANY),
	};
	int rc;
1477
	unsigned int h;
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518

	vs = kmalloc(sizeof(*vs), GFP_KERNEL);
	if (!vs)
		return ERR_PTR(-ENOMEM);

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

	INIT_WORK(&vs->del_work, vxlan_del_work);

	/* Create UDP socket for encapsulation receive. */
	rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &vs->sock);
	if (rc < 0) {
		pr_debug("UDP socket create failed\n");
		kfree(vs);
		return ERR_PTR(rc);
	}

	/* Put in proper namespace */
	sk = vs->sock->sk;
	sk_change_net(sk, net);

	vxlan_addr.sin_port = port;

	rc = kernel_bind(vs->sock, (struct sockaddr *) &vxlan_addr,
			 sizeof(vxlan_addr));
	if (rc < 0) {
		pr_debug("bind for UDP socket %pI4:%u (%d)\n",
			 &vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);
		sk_release_kernel(sk);
		kfree(vs);
		return ERR_PTR(rc);
	}

	/* Disable multicast loopback */
	inet_sk(sk)->mc_loop = 0;

	/* Mark socket as an encapsulation socket. */
	udp_sk(sk)->encap_type = 1;
	udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
	udp_encap_enable();
1519
	atomic_set(&vs->refcnt, 1);
1520 1521 1522 1523

	return vs;
}

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 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
/* Scheduled at device creation to bind to a socket */
static void vxlan_sock_work(struct work_struct *work)
{
	struct vxlan_dev *vxlan
		= container_of(work, struct vxlan_dev, sock_work);
	struct net_device *dev = vxlan->dev;
	struct net *net = dev_net(dev);
	__u32 vni = vxlan->default_dst.remote_vni;
	__be16 port = vxlan->dst_port;
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
	struct vxlan_sock *nvs, *ovs;

	nvs = vxlan_socket_create(net, port);
	if (IS_ERR(nvs)) {
		netdev_err(vxlan->dev, "Can not create UDP socket, %ld\n",
			   PTR_ERR(nvs));
		goto out;
	}

	spin_lock(&vn->sock_lock);
	/* Look again to see if can reuse socket */
	ovs = vxlan_find_port(net, port);
	if (ovs) {
		atomic_inc(&ovs->refcnt);
		vxlan->vn_sock = ovs;
		hlist_add_head_rcu(&vxlan->hlist, vni_head(ovs, vni));
		spin_unlock(&vn->sock_lock);

		sk_release_kernel(nvs->sock->sk);
		kfree(nvs);
	} else {
		vxlan->vn_sock = nvs;
		hlist_add_head_rcu(&nvs->hlist, vs_head(net, port));
		hlist_add_head_rcu(&vxlan->hlist, vni_head(nvs, vni));
		spin_unlock(&vn->sock_lock);
	}
out:
	dev_put(dev);
}

S
stephen hemminger 已提交
1564 1565 1566
static int vxlan_newlink(struct net *net, struct net_device *dev,
			 struct nlattr *tb[], struct nlattr *data[])
{
1567
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
S
stephen hemminger 已提交
1568
	struct vxlan_dev *vxlan = netdev_priv(dev);
1569
	struct vxlan_rdst *dst = &vxlan->default_dst;
S
stephen hemminger 已提交
1570 1571 1572 1573 1574 1575 1576
	__u32 vni;
	int err;

	if (!data[IFLA_VXLAN_ID])
		return -EINVAL;

	vni = nla_get_u32(data[IFLA_VXLAN_ID]);
1577
	dst->remote_vni = vni;
S
stephen hemminger 已提交
1578

1579 1580
	if (data[IFLA_VXLAN_GROUP])
		dst->remote_ip = nla_get_be32(data[IFLA_VXLAN_GROUP]);
S
stephen hemminger 已提交
1581 1582 1583 1584

	if (data[IFLA_VXLAN_LOCAL])
		vxlan->saddr = nla_get_be32(data[IFLA_VXLAN_LOCAL]);

1585
	if (data[IFLA_VXLAN_LINK] &&
1586
	    (dst->remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]))) {
1587
		struct net_device *lowerdev
1588
			 = __dev_get_by_index(net, dst->remote_ifindex);
1589 1590

		if (!lowerdev) {
1591
			pr_info("ifindex %d does not exist\n", dst->remote_ifindex);
1592 1593
			return -ENODEV;
		}
S
stephen hemminger 已提交
1594

1595
		if (!tb[IFLA_MTU])
S
stephen hemminger 已提交
1596
			dev->mtu = lowerdev->mtu - VXLAN_HEADROOM;
1597 1598 1599 1600

		/* update header length based on lower device */
		dev->hard_header_len = lowerdev->hard_header_len +
				       VXLAN_HEADROOM;
S
stephen hemminger 已提交
1601 1602 1603 1604 1605
	}

	if (data[IFLA_VXLAN_TOS])
		vxlan->tos  = nla_get_u8(data[IFLA_VXLAN_TOS]);

1606 1607 1608
	if (data[IFLA_VXLAN_TTL])
		vxlan->ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);

S
stephen hemminger 已提交
1609
	if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))
D
David Stevens 已提交
1610
		vxlan->flags |= VXLAN_F_LEARN;
S
stephen hemminger 已提交
1611 1612 1613 1614 1615 1616

	if (data[IFLA_VXLAN_AGEING])
		vxlan->age_interval = nla_get_u32(data[IFLA_VXLAN_AGEING]);
	else
		vxlan->age_interval = FDB_AGE_DEFAULT;

D
David Stevens 已提交
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
	if (data[IFLA_VXLAN_PROXY] && nla_get_u8(data[IFLA_VXLAN_PROXY]))
		vxlan->flags |= VXLAN_F_PROXY;

	if (data[IFLA_VXLAN_RSC] && nla_get_u8(data[IFLA_VXLAN_RSC]))
		vxlan->flags |= VXLAN_F_RSC;

	if (data[IFLA_VXLAN_L2MISS] && nla_get_u8(data[IFLA_VXLAN_L2MISS]))
		vxlan->flags |= VXLAN_F_L2MISS;

	if (data[IFLA_VXLAN_L3MISS] && nla_get_u8(data[IFLA_VXLAN_L3MISS]))
		vxlan->flags |= VXLAN_F_L3MISS;

S
stephen hemminger 已提交
1629 1630 1631
	if (data[IFLA_VXLAN_LIMIT])
		vxlan->addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);

1632 1633 1634 1635 1636 1637 1638
	if (data[IFLA_VXLAN_PORT_RANGE]) {
		const struct ifla_vxlan_port_range *p
			= nla_data(data[IFLA_VXLAN_PORT_RANGE]);
		vxlan->port_min = ntohs(p->low);
		vxlan->port_max = ntohs(p->high);
	}

1639 1640 1641
	if (data[IFLA_VXLAN_PORT])
		vxlan->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);

1642 1643 1644 1645 1646
	if (vxlan_find_vni(net, vni, vxlan->dst_port)) {
		pr_info("duplicate VNI %u\n", vni);
		return -EEXIST;
	}

Y
Yan Burman 已提交
1647 1648
	SET_ETHTOOL_OPS(dev, &vxlan_ethtool_ops);

S
stephen hemminger 已提交
1649
	err = register_netdevice(dev);
1650
	if (err)
1651
		return err;
S
stephen hemminger 已提交
1652

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

	return 0;
S
stephen hemminger 已提交
1656 1657 1658 1659 1660 1661 1662
}

static void vxlan_dellink(struct net_device *dev, struct list_head *head)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);

	hlist_del_rcu(&vxlan->hlist);
1663
	list_del(&vxlan->next);
S
stephen hemminger 已提交
1664 1665 1666 1667 1668 1669 1670
	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 */
1671
		nla_total_size(sizeof(__be32)) +/* IFLA_VXLAN_GROUP */
S
stephen hemminger 已提交
1672 1673 1674 1675 1676
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LINK */
		nla_total_size(sizeof(__be32))+	/* IFLA_VXLAN_LOCAL */
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TTL */
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TOS */
		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_LEARNING */
D
David Stevens 已提交
1677 1678 1679 1680
		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 */
S
stephen hemminger 已提交
1681 1682
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_AGEING */
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LIMIT */
1683
		nla_total_size(sizeof(struct ifla_vxlan_port_range)) +
1684
		nla_total_size(sizeof(__be16))+ /* IFLA_VXLAN_PORT */
S
stephen hemminger 已提交
1685 1686 1687 1688 1689 1690
		0;
}

static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
{
	const struct vxlan_dev *vxlan = netdev_priv(dev);
1691
	const struct vxlan_rdst *dst = &vxlan->default_dst;
1692 1693 1694 1695
	struct ifla_vxlan_port_range ports = {
		.low =  htons(vxlan->port_min),
		.high = htons(vxlan->port_max),
	};
S
stephen hemminger 已提交
1696

1697
	if (nla_put_u32(skb, IFLA_VXLAN_ID, dst->remote_vni))
S
stephen hemminger 已提交
1698 1699
		goto nla_put_failure;

1700
	if (dst->remote_ip && nla_put_be32(skb, IFLA_VXLAN_GROUP, dst->remote_ip))
S
stephen hemminger 已提交
1701 1702
		goto nla_put_failure;

1703
	if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))
S
stephen hemminger 已提交
1704 1705
		goto nla_put_failure;

1706
	if (vxlan->saddr && nla_put_be32(skb, IFLA_VXLAN_LOCAL, vxlan->saddr))
S
stephen hemminger 已提交
1707 1708 1709 1710
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->ttl) ||
	    nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->tos) ||
D
David Stevens 已提交
1711 1712 1713 1714 1715 1716 1717 1718 1719
	    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)) ||
S
stephen hemminger 已提交
1720
	    nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->age_interval) ||
1721 1722
	    nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->addrmax) ||
	    nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->dst_port))
S
stephen hemminger 已提交
1723 1724
		goto nla_put_failure;

1725 1726 1727
	if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))
		goto nla_put_failure;

S
stephen hemminger 已提交
1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

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

static __net_init int vxlan_init_net(struct net *net)
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
1750
	unsigned int h;
S
stephen hemminger 已提交
1751

1752
	INIT_LIST_HEAD(&vn->vxlan_list);
1753
	spin_lock_init(&vn->sock_lock);
S
stephen hemminger 已提交
1754

1755 1756
	for (h = 0; h < PORT_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&vn->sock_list[h]);
S
stephen hemminger 已提交
1757 1758 1759 1760 1761 1762 1763

	return 0;
}

static __net_exit void vxlan_exit_net(struct net *net)
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
1764 1765 1766
	struct vxlan_dev *vxlan;

	rtnl_lock();
1767 1768
	list_for_each_entry(vxlan, &vn->vxlan_list, next)
		dev_close(vxlan->dev);
1769
	rtnl_unlock();
S
stephen hemminger 已提交
1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
}

static struct pernet_operations vxlan_net_ops = {
	.init = vxlan_init_net,
	.exit = vxlan_exit_net,
	.id   = &vxlan_net_id,
	.size = sizeof(struct vxlan_net),
};

static int __init vxlan_init_module(void)
{
	int rc;

1783 1784 1785 1786
	vxlan_wq = alloc_workqueue("vxlan", 0, 0);
	if (!vxlan_wq)
		return -ENOMEM;

S
stephen hemminger 已提交
1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
	get_random_bytes(&vxlan_salt, sizeof(vxlan_salt));

	rc = register_pernet_device(&vxlan_net_ops);
	if (rc)
		goto out1;

	rc = rtnl_link_register(&vxlan_link_ops);
	if (rc)
		goto out2;

	return 0;

out2:
	unregister_pernet_device(&vxlan_net_ops);
out1:
1802
	destroy_workqueue(vxlan_wq);
S
stephen hemminger 已提交
1803 1804
	return rc;
}
1805
late_initcall(vxlan_init_module);
S
stephen hemminger 已提交
1806 1807 1808 1809

static void __exit vxlan_cleanup_module(void)
{
	unregister_pernet_device(&vxlan_net_ops);
1810
	rtnl_link_unregister(&vxlan_link_ops);
1811
	destroy_workqueue(vxlan_wq);
1812
	rcu_barrier();
S
stephen hemminger 已提交
1813 1814 1815 1816 1817
}
module_exit(vxlan_cleanup_module);

MODULE_LICENSE("GPL");
MODULE_VERSION(VXLAN_VERSION);
1818
MODULE_AUTHOR("Stephen Hemminger <stephen@networkplumber.org>");
S
stephen hemminger 已提交
1819
MODULE_ALIAS_RTNL_LINK("vxlan");