vxlan.c 47.0 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
/* UDP port for VXLAN traffic.
 * The IANA assigned port is 4789, but the Linux default is 8472
S
Stephen Hemminger 已提交
71
 * for compatibility with early adopters.
72
 */
73 74
static unsigned short vxlan_port __read_mostly = 8472;
module_param_named(udp_port, vxlan_port, ushort, 0444);
S
stephen hemminger 已提交
75 76 77 78 79 80
MODULE_PARM_DESC(udp_port, "Destination UDP port");

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

P
Pravin B Shelar 已提交
81
static int vxlan_net_id;
82

83 84
static const u8 all_zeros_mac[ETH_ALEN];

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

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

102 103 104 105 106
struct vxlan_rdst {
	__be32			 remote_ip;
	__be16			 remote_port;
	u32			 remote_vni;
	u32			 remote_ifindex;
107
	struct list_head	 list;
108
	struct rcu_head		 rcu;
109 110
};

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

/* Pseudo network device */
struct vxlan_dev {
125 126 127
	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 已提交
128
	struct net_device *dev;
129
	struct vxlan_rdst default_dst;	/* default destination */
S
stephen hemminger 已提交
130
	__be32		  saddr;	/* source address */
131
	__be16		  dst_port;
132 133
	__u16		  port_min;	/* source port range */
	__u16		  port_max;
S
stephen hemminger 已提交
134 135
	__u8		  tos;		/* TOS override */
	__u8		  ttl;
D
David Stevens 已提交
136
	u32		  flags;	/* VXLAN_F_* below */
S
stephen hemminger 已提交
137

138
	struct work_struct sock_work;
139
	struct work_struct igmp_work;
140

S
stephen hemminger 已提交
141 142 143 144 145 146 147 148 149
	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 已提交
150 151 152 153 154 155
#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 已提交
156 157
/* salt for hash table */
static u32 vxlan_salt __read_mostly;
158
static struct workqueue_struct *vxlan_wq;
S
stephen hemminger 已提交
159

160 161
static void vxlan_sock_work(struct work_struct *work);

162 163 164 165 166 167 168 169
/* 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 已提交
170 171 172
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);

173 174 175
	return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
}

176 177 178 179 180 181 182 183
/* First remote destination for a forwarding entry.
 * Guaranteed to be non-NULL because remotes are never deleted.
 */
static inline struct vxlan_rdst *first_remote(struct vxlan_fdb *fdb)
{
	return list_first_or_null_rcu(&fdb->remotes, struct vxlan_rdst, list);
}

184 185 186 187 188 189 190 191 192 193
/* 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 已提交
194 195 196
}

/* Look up VNI in a per net namespace table */
197
static struct vxlan_dev *vxlan_find_vni(struct net *net, u32 id, __be16 port)
S
stephen hemminger 已提交
198
{
199
	struct vxlan_sock *vs;
S
stephen hemminger 已提交
200 201
	struct vxlan_dev *vxlan;

202 203 204 205 206
	vs = vxlan_find_port(net, port);
	if (!vs)
		return NULL;

	hlist_for_each_entry_rcu(vxlan, vni_head(vs, id), hlist) {
207
		if (vxlan->default_dst.remote_vni == id)
S
stephen hemminger 已提交
208 209 210 211 212 213 214 215
			return vxlan;
	}

	return NULL;
}

/* Fill in neighbour message in skbuff. */
static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,
S
Stephen Hemminger 已提交
216 217 218
			  const struct vxlan_fdb *fdb,
			  u32 portid, u32 seq, int type, unsigned int flags,
			  const struct vxlan_rdst *rdst)
S
stephen hemminger 已提交
219 220 221 222 223
{
	unsigned long now = jiffies;
	struct nda_cacheinfo ci;
	struct nlmsghdr *nlh;
	struct ndmsg *ndm;
D
David Stevens 已提交
224
	bool send_ip, send_eth;
S
stephen hemminger 已提交
225 226 227 228 229 230 231

	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 已提交
232 233 234 235 236

	send_eth = send_ip = true;

	if (type == RTM_GETNEIGH) {
		ndm->ndm_family	= AF_INET;
237
		send_ip = rdst->remote_ip != htonl(INADDR_ANY);
D
David Stevens 已提交
238 239 240
		send_eth = !is_zero_ether_addr(fdb->eth_addr);
	} else
		ndm->ndm_family	= AF_BRIDGE;
S
stephen hemminger 已提交
241 242
	ndm->ndm_state = fdb->state;
	ndm->ndm_ifindex = vxlan->dev->ifindex;
243
	ndm->ndm_flags = fdb->flags;
S
stephen hemminger 已提交
244 245
	ndm->ndm_type = NDA_DST;

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

249 250 251
	if (send_ip && nla_put_be32(skb, NDA_DST, rdst->remote_ip))
		goto nla_put_failure;

252
	if (rdst->remote_port && rdst->remote_port != vxlan->dst_port &&
253 254
	    nla_put_be16(skb, NDA_PORT, rdst->remote_port))
		goto nla_put_failure;
255
	if (rdst->remote_vni != vxlan->default_dst.remote_vni &&
P
Pravin B Shelar 已提交
256
	    nla_put_u32(skb, NDA_VNI, rdst->remote_vni))
257 258 259
		goto nla_put_failure;
	if (rdst->remote_ifindex &&
	    nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
S
stephen hemminger 已提交
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
		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 */
282
		+ nla_total_size(sizeof(__be16)) /* NDA_PORT */
283 284
		+ nla_total_size(sizeof(__be32)) /* NDA_VNI */
		+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
S
stephen hemminger 已提交
285 286 287 288
		+ nla_total_size(sizeof(struct nda_cacheinfo));
}

static void vxlan_fdb_notify(struct vxlan_dev *vxlan,
289
			     struct vxlan_fdb *fdb, int type)
S
stephen hemminger 已提交
290 291 292 293 294 295 296 297 298
{
	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;

299
	err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0, first_remote(fdb));
S
stephen hemminger 已提交
300 301 302 303 304 305 306 307 308 309 310 311 312 313
	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 已提交
314 315 316
static void vxlan_ip_miss(struct net_device *dev, __be32 ipa)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
317 318 319 320 321 322 323
	struct vxlan_fdb f = {
		.state = NUD_STALE,
	};
	struct vxlan_rdst remote = {
		.remote_ip = ipa, /* goes to NDA_DST */
		.remote_vni = VXLAN_N_VID,
	};
324 325 326

	INIT_LIST_HEAD(&f.remotes);
	list_add_rcu(&remote.list, &f.remotes);
D
David Stevens 已提交
327 328 329 330 331 332

	vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
}

static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])
{
333 334 335
	struct vxlan_fdb f = {
		.state = NUD_STALE,
	};
D
David Stevens 已提交
336

337
	INIT_LIST_HEAD(&f.remotes);
D
David Stevens 已提交
338 339 340 341 342
	memcpy(f.eth_addr, eth_addr, ETH_ALEN);

	vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
}

S
stephen hemminger 已提交
343 344 345 346 347 348 349 350
/* 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;
351 352
#else
	value <<= 16;
S
stephen hemminger 已提交
353 354 355 356 357 358 359 360 361 362 363 364
#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 */
365
static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,
S
stephen hemminger 已提交
366 367 368 369 370 371
					const u8 *mac)

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

372
	hlist_for_each_entry_rcu(f, head, hlist) {
S
stephen hemminger 已提交
373 374 375 376 377 378 379
		if (compare_ether_addr(mac, f->eth_addr) == 0)
			return f;
	}

	return NULL;
}

380 381 382 383 384 385 386 387 388 389 390 391
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;
}

392 393 394 395
/* caller should hold vxlan->hash_lock */
static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,
					      __be32 ip, __be16 port,
					      __u32 vni, __u32 ifindex)
396
{
397
	struct vxlan_rdst *rd;
398

399
	list_for_each_entry(rd, &f->remotes, list) {
400 401 402 403
		if (rd->remote_ip == ip &&
		    rd->remote_port == port &&
		    rd->remote_vni == vni &&
		    rd->remote_ifindex == ifindex)
404
			return rd;
405
	}
406

407 408 409 410 411 412 413 414 415 416 417 418 419
	return NULL;
}

/* Add/update destinations for multicast */
static int vxlan_fdb_append(struct vxlan_fdb *f,
			    __be32 ip, __be16 port, __u32 vni, __u32 ifindex)
{
	struct vxlan_rdst *rd;

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

420 421 422 423 424 425 426
	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;
427 428 429

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

430 431 432
	return 1;
}

S
stephen hemminger 已提交
433 434 435
/* Add new entry to forwarding table -- assumes lock held */
static int vxlan_fdb_create(struct vxlan_dev *vxlan,
			    const u8 *mac, __be32 ip,
436
			    __u16 state, __u16 flags,
437
			    __be16 port, __u32 vni, __u32 ifindex,
438
			    __u8 ndm_flags)
S
stephen hemminger 已提交
439 440 441 442
{
	struct vxlan_fdb *f;
	int notify = 0;

443
	f = __vxlan_find_mac(vxlan, mac);
S
stephen hemminger 已提交
444 445 446 447 448 449 450 451 452 453 454
	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;
		}
455 456 457 458 459
		if (f->flags != ndm_flags) {
			f->flags = ndm_flags;
			f->updated = jiffies;
			notify = 1;
		}
460
		if ((flags & NLM_F_APPEND) &&
461 462
		    (is_multicast_ether_addr(f->eth_addr) ||
		     is_zero_ether_addr(f->eth_addr))) {
463 464 465 466 467 468
			int rc = vxlan_fdb_append(f, ip, port, vni, ifindex);

			if (rc < 0)
				return rc;
			notify |= rc;
		}
S
stephen hemminger 已提交
469 470 471 472 473 474 475 476 477 478 479 480 481 482
	} 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;
		f->state = state;
483
		f->flags = ndm_flags;
S
stephen hemminger 已提交
484
		f->updated = f->used = jiffies;
485
		INIT_LIST_HEAD(&f->remotes);
S
stephen hemminger 已提交
486 487
		memcpy(f->eth_addr, mac, ETH_ALEN);

488 489
		vxlan_fdb_append(f, ip, port, vni, ifindex);

S
stephen hemminger 已提交
490 491 492 493 494 495 496 497 498 499 500
		++vxlan->addrcnt;
		hlist_add_head_rcu(&f->hlist,
				   vxlan_fdb_head(vxlan, mac));
	}

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

	return 0;
}

501 502 503 504 505 506
static void vxlan_fdb_free_rdst(struct rcu_head *head)
{
	struct vxlan_rdst *rd = container_of(head, struct vxlan_rdst, rcu);
	kfree(rd);
}

W
Wei Yongjun 已提交
507
static void vxlan_fdb_free(struct rcu_head *head)
508 509
{
	struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);
510
	struct vxlan_rdst *rd, *nd;
511

512
	list_for_each_entry_safe(rd, nd, &f->remotes, list)
513 514 515 516
		kfree(rd);
	kfree(f);
}

S
stephen hemminger 已提交
517 518 519 520 521 522 523 524 525
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);
526
	call_rcu(&f->rcu, vxlan_fdb_free);
S
stephen hemminger 已提交
527 528
}

M
Mike Rapoport 已提交
529 530
static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,
			   __be32 *ip, __be16 *port, u32 *vni, u32 *ifindex)
S
stephen hemminger 已提交
531
{
532
	struct net *net = dev_net(vxlan->dev);
S
stephen hemminger 已提交
533

M
Mike Rapoport 已提交
534 535 536
	if (tb[NDA_DST]) {
		if (nla_len(tb[NDA_DST]) != sizeof(__be32))
			return -EAFNOSUPPORT;
S
stephen hemminger 已提交
537

M
Mike Rapoport 已提交
538 539 540 541
		*ip = nla_get_be32(tb[NDA_DST]);
	} else {
		*ip = htonl(INADDR_ANY);
	}
S
stephen hemminger 已提交
542

543
	if (tb[NDA_PORT]) {
544
		if (nla_len(tb[NDA_PORT]) != sizeof(__be16))
545
			return -EINVAL;
M
Mike Rapoport 已提交
546 547 548 549
		*port = nla_get_be16(tb[NDA_PORT]);
	} else {
		*port = vxlan->dst_port;
	}
550 551 552 553

	if (tb[NDA_VNI]) {
		if (nla_len(tb[NDA_VNI]) != sizeof(u32))
			return -EINVAL;
M
Mike Rapoport 已提交
554 555 556 557
		*vni = nla_get_u32(tb[NDA_VNI]);
	} else {
		*vni = vxlan->default_dst.remote_vni;
	}
558 559

	if (tb[NDA_IFINDEX]) {
P
Pravin B Shelar 已提交
560
		struct net_device *tdev;
561 562 563

		if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
			return -EINVAL;
M
Mike Rapoport 已提交
564 565
		*ifindex = nla_get_u32(tb[NDA_IFINDEX]);
		tdev = dev_get_by_index(net, *ifindex);
P
Pravin B Shelar 已提交
566
		if (!tdev)
567
			return -EADDRNOTAVAIL;
P
Pravin B Shelar 已提交
568
		dev_put(tdev);
M
Mike Rapoport 已提交
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
	} 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,
			 const unsigned char *addr, u16 flags)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	/* struct net *net = dev_net(vxlan->dev); */
	__be32 ip;
	__be16 port;
	u32 vni, ifindex;
	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;
600

S
stephen hemminger 已提交
601
	spin_lock_bh(&vxlan->hash_lock);
602 603
	err = vxlan_fdb_create(vxlan, addr, ip, ndm->ndm_state, flags,
			       port, vni, ifindex, ndm->ndm_flags);
S
stephen hemminger 已提交
604 605 606 607 608 609
	spin_unlock_bh(&vxlan->hash_lock);

	return err;
}

/* Delete entry (via netlink) */
610 611
static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
			    struct net_device *dev,
S
stephen hemminger 已提交
612 613 614 615
			    const unsigned char *addr)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb *f;
616 617 618 619 620 621 622 623 624 625 626
	struct vxlan_rdst *rd = NULL;
	__be32 ip;
	__be16 port;
	u32 vni, ifindex;
	int err;

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

	err = -ENOENT;
S
stephen hemminger 已提交
627 628 629

	spin_lock_bh(&vxlan->hash_lock);
	f = vxlan_find_mac(vxlan, addr);
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
	if (!f)
		goto out;

	if (ip != htonl(INADDR_ANY)) {
		rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
		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);
		call_rcu(&rd->rcu, vxlan_fdb_free_rdst);
		goto out;
S
stephen hemminger 已提交
648
	}
649 650 651 652

	vxlan_fdb_destroy(vxlan, f);

out:
S
stephen hemminger 已提交
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
	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;

669
		hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
670 671
			struct vxlan_rdst *rd;

672 673 674 675
			if (idx < cb->args[0])
				goto skip;

			list_for_each_entry_rcu(rd, &f->remotes, list) {
676 677 678 679 680 681
				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)
682
					goto out;
683
			}
684 685
skip:
			++idx;
S
stephen hemminger 已提交
686 687
		}
	}
688
out:
S
stephen hemminger 已提交
689 690 691 692 693
	return idx;
}

/* Watch incoming packets to learn mapping between Ethernet address
 * and Tunnel endpoint.
694
 * Return true if packet is bogus and should be droppped.
S
stephen hemminger 已提交
695
 */
696
static bool vxlan_snoop(struct net_device *dev,
S
stephen hemminger 已提交
697 698 699 700 701 702 703
			__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)) {
704 705 706
		struct vxlan_rdst *rdst = first_remote(f);

		if (likely(rdst->remote_ip == src_ip))
707 708 709
			return false;

		/* Don't migrate static entries, drop packets */
710
		if (f->state & NUD_NOARP)
711
			return true;
S
stephen hemminger 已提交
712 713 714 715

		if (net_ratelimit())
			netdev_info(dev,
				    "%pM migrated from %pI4 to %pI4\n",
716
				    src_mac, &rdst->remote_ip, &src_ip);
S
stephen hemminger 已提交
717

718
		rdst->remote_ip = src_ip;
S
stephen hemminger 已提交
719
		f->updated = jiffies;
720
		vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);
S
stephen hemminger 已提交
721 722 723
	} else {
		/* learned new entry */
		spin_lock(&vxlan->hash_lock);
724 725 726 727 728 729 730 731 732

		/* 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 已提交
733 734
		spin_unlock(&vxlan->hash_lock);
	}
735 736

	return false;
S
stephen hemminger 已提交
737 738 739 740
}


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

745 746 747
	list_for_each_entry(vxlan, &vn->vxlan_list, next) {
		if (!netif_running(vxlan->dev))
			continue;
S
stephen hemminger 已提交
748

749
		if (vxlan->default_dst.remote_ip == remote_ip)
750 751
			return true;
	}
S
stephen hemminger 已提交
752 753 754 755

	return false;
}

756
static void vxlan_sock_hold(struct vxlan_sock *vs)
S
stephen hemminger 已提交
757
{
758 759
	atomic_inc(&vs->refcnt);
}
S
stephen hemminger 已提交
760

761
static void vxlan_sock_release(struct vxlan_net *vn, struct vxlan_sock *vs)
762 763 764
{
	if (!atomic_dec_and_test(&vs->refcnt))
		return;
S
stephen hemminger 已提交
765

766
	spin_lock(&vn->sock_lock);
767
	hlist_del_rcu(&vs->hlist);
768 769
	spin_unlock(&vn->sock_lock);

770
	queue_work(vxlan_wq, &vs->del_work);
S
stephen hemminger 已提交
771 772
}

773 774 775 776
/* Callback to update multicast group membership.
 * Scheduled when vxlan goes up/down.
 */
static void vxlan_igmp_work(struct work_struct *work)
S
stephen hemminger 已提交
777
{
778 779 780 781
	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 已提交
782
	struct ip_mreqn mreq = {
783 784
		.imr_multiaddr.s_addr	= vxlan->default_dst.remote_ip,
		.imr_ifindex		= vxlan->default_dst.remote_ifindex,
S
stephen hemminger 已提交
785 786 787
	};

	lock_sock(sk);
788 789 790 791
	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 已提交
792 793
	release_sock(sk);

794
	vxlan_sock_release(vn, vs);
795
	dev_put(vxlan->dev);
S
stephen hemminger 已提交
796 797 798 799 800 801 802 803
}

/* 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;
804
	struct pcpu_tstats *stats;
805
	__be16 port;
S
stephen hemminger 已提交
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
	__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;
829 830
	port = inet_sk(sk)->inet_sport;
	vxlan = vxlan_find_vni(sock_net(sk), vni, port);
S
stephen hemminger 已提交
831
	if (!vxlan) {
832 833
		netdev_dbg(skb->dev, "unknown vni %d port %u\n",
			   vni, ntohs(port));
S
stephen hemminger 已提交
834 835 836 837 838 839 840 841 842
		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 已提交
843 844
	skb_reset_mac_header(skb);

S
stephen hemminger 已提交
845 846 847 848 849 850 851 852 853
	/* 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;

854 855 856
	if ((vxlan->flags & VXLAN_F_LEARN) &&
	    vxlan_snoop(skb->dev, oip->saddr, eth_hdr(skb)->h_source))
		goto drop;
S
stephen hemminger 已提交
857 858 859

	__skb_tunnel_rx(skb, vxlan->dev);
	skb_reset_network_header(skb);
860 861 862 863 864 865 866 867 868 869 870

	/* 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 已提交
871 872 873 874 875 876 877 878 879 880 881 882 883

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

884
	stats = this_cpu_ptr(vxlan->dev->tstats);
S
stephen hemminger 已提交
885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903
	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 已提交
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 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
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);
952
		if (f && first_remote(f)->remote_ip == htonl(INADDR_ANY)) {
D
David Stevens 已提交
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
			/* 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;
}

1014
static void vxlan_sock_put(struct sk_buff *skb)
1015 1016 1017 1018 1019 1020 1021
{
	sock_put(skb->sk);
}

/* On transmit, associate with the tunnel socket */
static void vxlan_set_owner(struct net_device *dev, struct sk_buff *skb)
{
1022 1023
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct sock *sk = vxlan->vn_sock->sock->sk;
1024 1025 1026 1027

	skb_orphan(skb);
	sock_hold(sk);
	skb->sk = sk;
1028
	skb->destructor = vxlan_sock_put;
1029 1030
}

1031 1032 1033 1034 1035
/* 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
 */
1036
static __be16 vxlan_src_port(const struct vxlan_dev *vxlan, struct sk_buff *skb)
1037 1038 1039 1040 1041 1042 1043 1044 1045
{
	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);

1046
	return htons((((u64) hash * range) >> 32) + vxlan->port_min);
1047 1048
}

1049 1050 1051 1052 1053 1054 1055
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 已提交
1056
		skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
1057 1058 1059 1060 1061 1062
	} else if (skb->ip_summed != CHECKSUM_PARTIAL)
		skb->ip_summed = CHECKSUM_NONE;

	return 0;
}

1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
/* 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)
1076 1077
		vxlan_snoop(skb->dev, htonl(INADDR_LOOPBACK),
			    eth_hdr(skb)->h_source);
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093

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

1094 1095
static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
			   struct vxlan_rdst *rdst, bool did_rsc)
S
stephen hemminger 已提交
1096 1097 1098 1099 1100 1101 1102 1103
{
	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;
1104
	__be16 src_port, dst_port;
S
Stephen Hemminger 已提交
1105
	u32 vni;
S
stephen hemminger 已提交
1106 1107
	__be16 df = 0;
	__u8 tos, ttl;
1108
	int err;
S
stephen hemminger 已提交
1109

1110
	dst_port = rdst->remote_port ? rdst->remote_port : vxlan->dst_port;
1111 1112
	vni = rdst->remote_vni;
	dst = rdst->remote_ip;
D
David Stevens 已提交
1113 1114 1115 1116

	if (!dst) {
		if (did_rsc) {
			/* short-circuited back to local bridge */
1117
			vxlan_encap_bypass(skb, vxlan, vxlan);
1118
			return;
D
David Stevens 已提交
1119
		}
1120
		goto drop;
D
David Stevens 已提交
1121
	}
1122

1123 1124 1125 1126 1127
	if (!skb->encapsulation) {
		skb_reset_inner_headers(skb);
		skb->encapsulation = 1;
	}

S
stephen hemminger 已提交
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
	/* 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)
1140
		tos = ip_tunnel_get_dsfield(old_iph, skb);
S
stephen hemminger 已提交
1141

1142
	src_port = vxlan_src_port(vxlan, skb);
S
stephen hemminger 已提交
1143

S
stephen hemminger 已提交
1144
	memset(&fl4, 0, sizeof(fl4));
1145
	fl4.flowi4_oif = rdst->remote_ifindex;
S
stephen hemminger 已提交
1146 1147 1148 1149 1150
	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 已提交
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
	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;
	}

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

		ip_rt_put(rt);
1170
		dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);
1171 1172 1173
		if (!dst_vxlan)
			goto tx_error;
		vxlan_encap_bypass(skb, vxlan, dst_vxlan);
1174
		return;
1175
	}
S
stephen hemminger 已提交
1176 1177
	vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
	vxh->vx_flags = htonl(VXLAN_FLAGS);
1178
	vxh->vx_vni = htonl(vni << 8);
S
stephen hemminger 已提交
1179 1180 1181 1182 1183

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

1184
	uh->dest = dst_port;
1185
	uh->source = src_port;
S
stephen hemminger 已提交
1186 1187 1188 1189

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

1190 1191
	vxlan_set_owner(dev, skb);

1192 1193
	if (handle_offloads(skb))
		goto drop;
S
stephen hemminger 已提交
1194

1195 1196 1197 1198 1199 1200 1201
	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);

1202
	return;
S
stephen hemminger 已提交
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213

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

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

1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
/* 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;
1225
	struct vxlan_rdst *rdst;
1226 1227 1228 1229 1230 1231 1232 1233 1234
	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);
1235 1236 1237 1238 1239 1240 1241 1242 1243
	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);
	}

1244
	if (f == NULL) {
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
		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++;
			dev_kfree_skb(skb);
			return NETDEV_TX_OK;
		}
	}
1256

1257 1258
	list_for_each_entry_rcu(rdst, &f->remotes, list) {
		struct sk_buff *skb1;
1259

1260 1261 1262
		skb1 = skb_clone(skb, GFP_ATOMIC);
		if (skb1)
			vxlan_xmit_one(skb1, dev, rdst, did_rsc);
1263 1264
	}

1265
	dev_kfree_skb(skb);
1266
	return NETDEV_TX_OK;
1267 1268
}

S
stephen hemminger 已提交
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
/* 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;

1287
			if (f->state & NUD_PERMANENT)
S
stephen hemminger 已提交
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
				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)
{
1309 1310 1311 1312 1313
	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;

1314 1315
	dev->tstats = alloc_percpu(struct pcpu_tstats);
	if (!dev->tstats)
S
stephen hemminger 已提交
1316 1317
		return -ENOMEM;

1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331
	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 已提交
1332 1333 1334
	return 0;
}

1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
static void vxlan_fdb_delete_defualt(struct vxlan_dev *vxlan)
{
	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);
}

1346 1347 1348 1349 1350 1351
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;

1352 1353
	vxlan_fdb_delete_defualt(vxlan);

1354 1355 1356 1357 1358
	if (vs)
		vxlan_sock_release(vn, vs);
	free_percpu(dev->tstats);
}

S
stephen hemminger 已提交
1359 1360 1361 1362
/* 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);
1363 1364 1365 1366 1367
	struct vxlan_sock *vs = vxlan->vn_sock;

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

1369
	if (IN_MULTICAST(ntohl(vxlan->default_dst.remote_ip))) {
1370
		vxlan_sock_hold(vs);
1371 1372
		dev_hold(dev);
		queue_work(vxlan_wq, &vxlan->igmp_work);
S
stephen hemminger 已提交
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383
	}

	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)
{
1384
	unsigned int h;
S
stephen hemminger 已提交
1385 1386 1387 1388 1389 1390 1391

	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);
1392 1393 1394
			/* 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 已提交
1395 1396 1397 1398 1399 1400 1401 1402 1403
		}
	}
	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);
1404
	struct vxlan_sock *vs = vxlan->vn_sock;
S
stephen hemminger 已提交
1405

1406 1407
	if (vs && IN_MULTICAST(ntohl(vxlan->default_dst.remote_ip))) {
		vxlan_sock_hold(vs);
1408 1409 1410
		dev_hold(dev);
		queue_work(vxlan_wq, &vxlan->igmp_work);
	}
S
stephen hemminger 已提交
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425

	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,
1426
	.ndo_uninit		= vxlan_uninit,
S
stephen hemminger 已提交
1427 1428 1429
	.ndo_open		= vxlan_open,
	.ndo_stop		= vxlan_stop,
	.ndo_start_xmit		= vxlan_xmit,
1430
	.ndo_get_stats64	= ip_tunnel_get_stats64,
S
stephen hemminger 已提交
1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
	.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);
1449
	unsigned int h;
1450
	int low, high;
S
stephen hemminger 已提交
1451 1452 1453

	eth_hw_addr_random(dev);
	ether_setup(dev);
S
stephen hemminger 已提交
1454
	dev->hard_header_len = ETH_HLEN + VXLAN_HEADROOM;
S
stephen hemminger 已提交
1455 1456

	dev->netdev_ops = &vxlan_netdev_ops;
1457
	dev->destructor = free_netdev;
S
stephen hemminger 已提交
1458 1459 1460 1461 1462
	SET_NETDEV_DEVTYPE(dev, &vxlan_type);

	dev->tx_queue_len = 0;
	dev->features	|= NETIF_F_LLTX;
	dev->features	|= NETIF_F_NETNS_LOCAL;
1463
	dev->features	|= NETIF_F_SG | NETIF_F_HW_CSUM;
1464
	dev->features   |= NETIF_F_RXCSUM;
1465
	dev->features   |= NETIF_F_GSO_SOFTWARE;
1466 1467

	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1468
	dev->hw_features |= NETIF_F_GSO_SOFTWARE;
S
stephen hemminger 已提交
1469
	dev->priv_flags	&= ~IFF_XMIT_DST_RELEASE;
1470
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
S
stephen hemminger 已提交
1471

1472
	INIT_LIST_HEAD(&vxlan->next);
S
stephen hemminger 已提交
1473
	spin_lock_init(&vxlan->hash_lock);
1474
	INIT_WORK(&vxlan->igmp_work, vxlan_igmp_work);
1475
	INIT_WORK(&vxlan->sock_work, vxlan_sock_work);
S
stephen hemminger 已提交
1476 1477 1478 1479 1480

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

1481 1482 1483
	inet_get_local_port_range(&low, &high);
	vxlan->port_min = low;
	vxlan->port_max = high;
1484
	vxlan->dst_port = htons(vxlan_port);
1485

S
stephen hemminger 已提交
1486 1487 1488 1489 1490 1491 1492 1493
	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 },
1494
	[IFLA_VXLAN_GROUP]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
S
stephen hemminger 已提交
1495 1496 1497 1498 1499 1500 1501
	[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 },
1502
	[IFLA_VXLAN_PORT_RANGE] = { .len  = sizeof(struct ifla_vxlan_port_range) },
D
David Stevens 已提交
1503 1504 1505 1506
	[IFLA_VXLAN_PROXY]	= { .type = NLA_U8 },
	[IFLA_VXLAN_RSC]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L2MISS]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L3MISS]	= { .type = NLA_U8 },
1507
	[IFLA_VXLAN_PORT]	= { .type = NLA_U16 },
S
stephen hemminger 已提交
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
};

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

1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
	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 已提交
1544 1545 1546
	return 0;
}

Y
Yan Burman 已提交
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558
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,
};

1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
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),
1574
		.sin_port = port,
1575 1576
	};
	int rc;
1577
	unsigned int h;
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616

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

	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();
1617
	atomic_set(&vs->refcnt, 1);
1618 1619 1620 1621

	return vs;
}

1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
/* 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 已提交
1662 1663 1664
static int vxlan_newlink(struct net *net, struct net_device *dev,
			 struct nlattr *tb[], struct nlattr *data[])
{
1665
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
S
stephen hemminger 已提交
1666
	struct vxlan_dev *vxlan = netdev_priv(dev);
1667
	struct vxlan_rdst *dst = &vxlan->default_dst;
S
stephen hemminger 已提交
1668 1669 1670 1671 1672 1673 1674
	__u32 vni;
	int err;

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

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

1677 1678
	if (data[IFLA_VXLAN_GROUP])
		dst->remote_ip = nla_get_be32(data[IFLA_VXLAN_GROUP]);
S
stephen hemminger 已提交
1679 1680 1681 1682

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

1683
	if (data[IFLA_VXLAN_LINK] &&
1684
	    (dst->remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]))) {
1685
		struct net_device *lowerdev
1686
			 = __dev_get_by_index(net, dst->remote_ifindex);
1687 1688

		if (!lowerdev) {
1689
			pr_info("ifindex %d does not exist\n", dst->remote_ifindex);
1690 1691
			return -ENODEV;
		}
S
stephen hemminger 已提交
1692

1693
		if (!tb[IFLA_MTU])
S
stephen hemminger 已提交
1694
			dev->mtu = lowerdev->mtu - VXLAN_HEADROOM;
1695 1696 1697 1698

		/* update header length based on lower device */
		dev->hard_header_len = lowerdev->hard_header_len +
				       VXLAN_HEADROOM;
S
stephen hemminger 已提交
1699 1700 1701 1702 1703
	}

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

1704 1705 1706
	if (data[IFLA_VXLAN_TTL])
		vxlan->ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);

S
stephen hemminger 已提交
1707
	if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))
D
David Stevens 已提交
1708
		vxlan->flags |= VXLAN_F_LEARN;
S
stephen hemminger 已提交
1709 1710 1711 1712 1713 1714

	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 已提交
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
	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 已提交
1727 1728 1729
	if (data[IFLA_VXLAN_LIMIT])
		vxlan->addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);

1730 1731 1732 1733 1734 1735 1736
	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);
	}

1737 1738 1739
	if (data[IFLA_VXLAN_PORT])
		vxlan->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);

1740 1741 1742 1743 1744
	if (vxlan_find_vni(net, vni, vxlan->dst_port)) {
		pr_info("duplicate VNI %u\n", vni);
		return -EEXIST;
	}

Y
Yan Burman 已提交
1745 1746
	SET_ETHTOOL_OPS(dev, &vxlan_ethtool_ops);

1747 1748 1749 1750 1751 1752 1753
	/* create an fdb entry for default destination */
	err = vxlan_fdb_create(vxlan, all_zeros_mac,
			       vxlan->default_dst.remote_ip,
			       NUD_REACHABLE|NUD_PERMANENT,
			       NLM_F_EXCL|NLM_F_CREATE,
			       vxlan->dst_port, vxlan->default_dst.remote_vni,
			       vxlan->default_dst.remote_ifindex, NTF_SELF);
1754
	if (err)
1755
		return err;
S
stephen hemminger 已提交
1756

1757 1758 1759 1760 1761 1762
	err = register_netdevice(dev);
	if (err) {
		vxlan_fdb_delete_defualt(vxlan);
		return err;
	}

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

	return 0;
S
stephen hemminger 已提交
1766 1767 1768 1769 1770 1771 1772
}

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

	hlist_del_rcu(&vxlan->hlist);
1773
	list_del(&vxlan->next);
S
stephen hemminger 已提交
1774 1775 1776 1777 1778 1779 1780
	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 */
1781
		nla_total_size(sizeof(__be32)) +/* IFLA_VXLAN_GROUP */
S
stephen hemminger 已提交
1782 1783 1784 1785 1786
		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 已提交
1787 1788 1789 1790
		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 已提交
1791 1792
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_AGEING */
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LIMIT */
1793
		nla_total_size(sizeof(struct ifla_vxlan_port_range)) +
1794
		nla_total_size(sizeof(__be16))+ /* IFLA_VXLAN_PORT */
S
stephen hemminger 已提交
1795 1796 1797 1798 1799 1800
		0;
}

static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
{
	const struct vxlan_dev *vxlan = netdev_priv(dev);
1801
	const struct vxlan_rdst *dst = &vxlan->default_dst;
1802 1803 1804 1805
	struct ifla_vxlan_port_range ports = {
		.low =  htons(vxlan->port_min),
		.high = htons(vxlan->port_max),
	};
S
stephen hemminger 已提交
1806

1807
	if (nla_put_u32(skb, IFLA_VXLAN_ID, dst->remote_vni))
S
stephen hemminger 已提交
1808 1809
		goto nla_put_failure;

1810
	if (dst->remote_ip && nla_put_be32(skb, IFLA_VXLAN_GROUP, dst->remote_ip))
S
stephen hemminger 已提交
1811 1812
		goto nla_put_failure;

1813
	if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))
S
stephen hemminger 已提交
1814 1815
		goto nla_put_failure;

1816
	if (vxlan->saddr && nla_put_be32(skb, IFLA_VXLAN_LOCAL, vxlan->saddr))
S
stephen hemminger 已提交
1817 1818 1819 1820
		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 已提交
1821 1822 1823 1824 1825 1826 1827 1828 1829
	    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 已提交
1830
	    nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->age_interval) ||
1831 1832
	    nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->addrmax) ||
	    nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->dst_port))
S
stephen hemminger 已提交
1833 1834
		goto nla_put_failure;

1835 1836 1837
	if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))
		goto nla_put_failure;

S
stephen hemminger 已提交
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859
	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);
1860
	unsigned int h;
S
stephen hemminger 已提交
1861

1862
	INIT_LIST_HEAD(&vn->vxlan_list);
1863
	spin_lock_init(&vn->sock_lock);
S
stephen hemminger 已提交
1864

1865 1866
	for (h = 0; h < PORT_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&vn->sock_list[h]);
S
stephen hemminger 已提交
1867 1868 1869 1870 1871 1872 1873

	return 0;
}

static __net_exit void vxlan_exit_net(struct net *net)
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
1874 1875 1876
	struct vxlan_dev *vxlan;

	rtnl_lock();
1877 1878
	list_for_each_entry(vxlan, &vn->vxlan_list, next)
		dev_close(vxlan->dev);
1879
	rtnl_unlock();
S
stephen hemminger 已提交
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892
}

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;

1893 1894 1895 1896
	vxlan_wq = alloc_workqueue("vxlan", 0, 0);
	if (!vxlan_wq)
		return -ENOMEM;

S
stephen hemminger 已提交
1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
	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:
1912
	destroy_workqueue(vxlan_wq);
S
stephen hemminger 已提交
1913 1914
	return rc;
}
1915
late_initcall(vxlan_init_module);
S
stephen hemminger 已提交
1916 1917 1918 1919

static void __exit vxlan_cleanup_module(void)
{
	unregister_pernet_device(&vxlan_net_ops);
1920
	rtnl_link_unregister(&vxlan_link_ops);
1921
	destroy_workqueue(vxlan_wq);
1922
	rcu_barrier();
S
stephen hemminger 已提交
1923 1924 1925 1926 1927
}
module_exit(vxlan_cleanup_module);

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