vxlan.c 63.3 KB
Newer Older
S
stephen hemminger 已提交
1
/*
R
Rami Rosen 已提交
2
 * VXLAN: Virtual eXtensible Local Area Network
S
stephen hemminger 已提交
3
 *
4
 * Copyright (c) 2012-2013 Vyatta Inc.
S
stephen hemminger 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/rculist.h>
#include <linux/netdevice.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <linux/igmp.h>
#include <linux/etherdevice.h>
#include <linux/if_ether.h>
27
#include <linux/if_vlan.h>
S
stephen hemminger 已提交
28
#include <linux/hash.h>
Y
Yan Burman 已提交
29
#include <linux/ethtool.h>
D
David Stevens 已提交
30 31
#include <net/arp.h>
#include <net/ndisc.h>
S
stephen hemminger 已提交
32
#include <net/ip.h>
33
#include <net/ip_tunnels.h>
S
stephen hemminger 已提交
34 35 36 37 38 39 40 41
#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>
42
#include <net/vxlan.h>
C
Cong Wang 已提交
43 44 45 46 47
#if IS_ENABLED(CONFIG_IPV6)
#include <net/ipv6.h>
#include <net/addrconf.h>
#include <net/ip6_tunnel.h>
#endif
S
stephen hemminger 已提交
48 49 50

#define VXLAN_VERSION	"0.1"

51 52
#define PORT_HASH_BITS	8
#define PORT_HASH_SIZE  (1<<PORT_HASH_BITS)
S
stephen hemminger 已提交
53 54 55 56 57 58 59 60 61
#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)
62 63
/* IP header + UDP + VXLAN + Ethernet header */
#define VXLAN_HEADROOM (20 + 8 + 8 + 14)
C
Cong Wang 已提交
64 65
/* IPv6 header + UDP + VXLAN + Ethernet header */
#define VXLAN6_HEADROOM (40 + 8 + 8 + 14)
66
#define VXLAN_HLEN (sizeof(struct udphdr) + sizeof(struct vxlanhdr))
S
stephen hemminger 已提交
67 68 69 70 71 72 73 74 75

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

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

76 77
/* UDP port for VXLAN traffic.
 * The IANA assigned port is 4789, but the Linux default is 8472
S
Stephen Hemminger 已提交
78
 * for compatibility with early adopters.
79
 */
80 81
static unsigned short vxlan_port __read_mostly = 8472;
module_param_named(udp_port, vxlan_port, ushort, 0444);
S
stephen hemminger 已提交
82 83 84 85 86 87
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 已提交
88
static int vxlan_net_id;
89

90 91
static const u8 all_zeros_mac[ETH_ALEN];

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

C
Cong Wang 已提交
99 100 101 102 103 104
union vxlan_addr {
	struct sockaddr_in sin;
	struct sockaddr_in6 sin6;
	struct sockaddr sa;
};

105
struct vxlan_rdst {
C
Cong Wang 已提交
106
	union vxlan_addr	 remote_ip;
107 108 109
	__be16			 remote_port;
	u32			 remote_vni;
	u32			 remote_ifindex;
110
	struct list_head	 list;
111
	struct rcu_head		 rcu;
112 113
};

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

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

141
	struct work_struct sock_work;
S
stephen hemminger 已提交
142 143
	struct work_struct igmp_join;
	struct work_struct igmp_leave;
144

S
stephen hemminger 已提交
145 146 147 148 149 150 151 152 153
	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 已提交
154 155 156 157 158
#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
C
Cong Wang 已提交
159
#define VXLAN_F_IPV6	0x20 /* internal flag */
D
David Stevens 已提交
160

S
stephen hemminger 已提交
161 162
/* salt for hash table */
static u32 vxlan_salt __read_mostly;
163
static struct workqueue_struct *vxlan_wq;
S
stephen hemminger 已提交
164

165 166
static void vxlan_sock_work(struct work_struct *work);

C
Cong Wang 已提交
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
#if IS_ENABLED(CONFIG_IPV6)
static inline
bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
{
       if (a->sa.sa_family != b->sa.sa_family)
               return false;
       if (a->sa.sa_family == AF_INET6)
               return ipv6_addr_equal(&a->sin6.sin6_addr, &b->sin6.sin6_addr);
       else
               return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
}

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
{
       if (ipa->sa.sa_family == AF_INET6)
               return ipv6_addr_any(&ipa->sin6.sin6_addr);
       else
               return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
}

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
{
       if (ipa->sa.sa_family == AF_INET6)
               return ipv6_addr_is_multicast(&ipa->sin6.sin6_addr);
       else
               return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
}

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
{
       if (nla_len(nla) >= sizeof(struct in6_addr)) {
               nla_memcpy(&ip->sin6.sin6_addr, nla, sizeof(struct in6_addr));
               ip->sa.sa_family = AF_INET6;
               return 0;
       } else if (nla_len(nla) >= sizeof(__be32)) {
               ip->sin.sin_addr.s_addr = nla_get_be32(nla);
               ip->sa.sa_family = AF_INET;
               return 0;
       } else {
               return -EAFNOSUPPORT;
       }
}

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
                             const union vxlan_addr *ip)
{
       if (ip->sa.sa_family == AF_INET6)
               return nla_put(skb, attr, sizeof(struct in6_addr), &ip->sin6.sin6_addr);
       else
               return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);
}

#else /* !CONFIG_IPV6 */

static inline
bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
{
       return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
}

static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
{
       return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
}

static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
{
       return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
}

static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
{
       if (nla_len(nla) >= sizeof(struct in6_addr)) {
               return -EAFNOSUPPORT;
       } else if (nla_len(nla) >= sizeof(__be32)) {
               ip->sin.sin_addr.s_addr = nla_get_be32(nla);
               ip->sa.sa_family = AF_INET;
               return 0;
       } else {
               return -EAFNOSUPPORT;
       }
}

static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
                             const union vxlan_addr *ip)
{
       return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);
}
#endif

257 258 259 260 261 262 263 264
/* 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 已提交
265 266 267
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);

268 269 270
	return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
}

271 272 273
/* First remote destination for a forwarding entry.
 * Guaranteed to be non-NULL because remotes are never deleted.
 */
274
static inline struct vxlan_rdst *first_remote_rcu(struct vxlan_fdb *fdb)
275
{
276 277 278 279 280 281
	return list_entry_rcu(fdb->remotes.next, struct vxlan_rdst, list);
}

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

284
/* Find VXLAN socket based on network namespace and UDP port */
285
static struct vxlan_sock *vxlan_find_sock(struct net *net, __be16 port)
286 287 288 289 290 291 292 293
{
	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 已提交
294 295
}

P
Pravin B Shelar 已提交
296
static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs, u32 id)
S
stephen hemminger 已提交
297 298 299
{
	struct vxlan_dev *vxlan;

300
	hlist_for_each_entry_rcu(vxlan, vni_head(vs, id), hlist) {
301
		if (vxlan->default_dst.remote_vni == id)
S
stephen hemminger 已提交
302 303 304 305 306 307
			return vxlan;
	}

	return NULL;
}

P
Pravin B Shelar 已提交
308 309 310 311 312 313 314 315 316 317 318 319
/* Look up VNI in a per net namespace table */
static struct vxlan_dev *vxlan_find_vni(struct net *net, u32 id, __be16 port)
{
	struct vxlan_sock *vs;

	vs = vxlan_find_sock(net, port);
	if (!vs)
		return NULL;

	return vxlan_vs_find_vni(vs, id);
}

S
stephen hemminger 已提交
320 321
/* Fill in neighbour message in skbuff. */
static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,
S
Stephen Hemminger 已提交
322 323 324
			  const struct vxlan_fdb *fdb,
			  u32 portid, u32 seq, int type, unsigned int flags,
			  const struct vxlan_rdst *rdst)
S
stephen hemminger 已提交
325 326 327 328 329
{
	unsigned long now = jiffies;
	struct nda_cacheinfo ci;
	struct nlmsghdr *nlh;
	struct ndmsg *ndm;
D
David Stevens 已提交
330
	bool send_ip, send_eth;
S
stephen hemminger 已提交
331 332 333 334 335 336 337

	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 已提交
338 339 340 341 342

	send_eth = send_ip = true;

	if (type == RTM_GETNEIGH) {
		ndm->ndm_family	= AF_INET;
C
Cong Wang 已提交
343
		send_ip = !vxlan_addr_any(&rdst->remote_ip);
D
David Stevens 已提交
344 345 346
		send_eth = !is_zero_ether_addr(fdb->eth_addr);
	} else
		ndm->ndm_family	= AF_BRIDGE;
S
stephen hemminger 已提交
347 348
	ndm->ndm_state = fdb->state;
	ndm->ndm_ifindex = vxlan->dev->ifindex;
349
	ndm->ndm_flags = fdb->flags;
S
stephen hemminger 已提交
350 351
	ndm->ndm_type = NDA_DST;

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

C
Cong Wang 已提交
355
	if (send_ip && vxlan_nla_put_addr(skb, NDA_DST, &rdst->remote_ip))
356 357
		goto nla_put_failure;

358
	if (rdst->remote_port && rdst->remote_port != vxlan->dst_port &&
359 360
	    nla_put_be16(skb, NDA_PORT, rdst->remote_port))
		goto nla_put_failure;
361
	if (rdst->remote_vni != vxlan->default_dst.remote_vni &&
P
Pravin B Shelar 已提交
362
	    nla_put_u32(skb, NDA_VNI, rdst->remote_vni))
363 364 365
		goto nla_put_failure;
	if (rdst->remote_ifindex &&
	    nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
S
stephen hemminger 已提交
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
		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 */
C
Cong Wang 已提交
387
		+ nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */
388
		+ nla_total_size(sizeof(__be16)) /* NDA_PORT */
389 390
		+ nla_total_size(sizeof(__be32)) /* NDA_VNI */
		+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
S
stephen hemminger 已提交
391 392 393 394
		+ nla_total_size(sizeof(struct nda_cacheinfo));
}

static void vxlan_fdb_notify(struct vxlan_dev *vxlan,
395
			     struct vxlan_fdb *fdb, int type)
S
stephen hemminger 已提交
396 397 398 399 400 401 402 403 404
{
	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;

405 406
	err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0,
			     first_remote_rtnl(fdb));
S
stephen hemminger 已提交
407 408 409 410 411 412 413 414 415 416 417 418 419 420
	if (err < 0) {
		/* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}

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

C
Cong Wang 已提交
421
static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)
D
David Stevens 已提交
422 423
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
424 425 426 427
	struct vxlan_fdb f = {
		.state = NUD_STALE,
	};
	struct vxlan_rdst remote = {
C
Cong Wang 已提交
428
		.remote_ip = *ipa, /* goes to NDA_DST */
429 430
		.remote_vni = VXLAN_N_VID,
	};
431 432 433

	INIT_LIST_HEAD(&f.remotes);
	list_add_rcu(&remote.list, &f.remotes);
D
David Stevens 已提交
434 435 436 437 438 439

	vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
}

static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])
{
440 441 442
	struct vxlan_fdb f = {
		.state = NUD_STALE,
	};
D
David Stevens 已提交
443

444
	INIT_LIST_HEAD(&f.remotes);
D
David Stevens 已提交
445 446 447 448 449
	memcpy(f.eth_addr, eth_addr, ETH_ALEN);

	vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
}

S
stephen hemminger 已提交
450 451 452 453 454 455 456 457
/* 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;
458 459
#else
	value <<= 16;
S
stephen hemminger 已提交
460 461 462 463 464 465 466 467 468 469 470 471
#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 */
472
static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,
S
stephen hemminger 已提交
473 474 475 476 477 478
					const u8 *mac)

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

479
	hlist_for_each_entry_rcu(f, head, hlist) {
S
stephen hemminger 已提交
480 481 482 483 484 485 486
		if (compare_ether_addr(mac, f->eth_addr) == 0)
			return f;
	}

	return NULL;
}

487 488 489 490 491 492 493 494 495 496 497 498
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;
}

499 500
/* caller should hold vxlan->hash_lock */
static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,
C
Cong Wang 已提交
501
					      union vxlan_addr *ip, __be16 port,
502
					      __u32 vni, __u32 ifindex)
503
{
504
	struct vxlan_rdst *rd;
505

506
	list_for_each_entry(rd, &f->remotes, list) {
C
Cong Wang 已提交
507
		if (vxlan_addr_equal(&rd->remote_ip, ip) &&
508 509 510
		    rd->remote_port == port &&
		    rd->remote_vni == vni &&
		    rd->remote_ifindex == ifindex)
511
			return rd;
512
	}
513

514 515 516
	return NULL;
}

517 518
/* Replace destination of unicast mac */
static int vxlan_fdb_replace(struct vxlan_fdb *f,
C
Cong Wang 已提交
519
			     union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)
520 521 522 523 524 525 526 527 528 529
{
	struct vxlan_rdst *rd;

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

	rd = list_first_entry_or_null(&f->remotes, struct vxlan_rdst, list);
	if (!rd)
		return 0;
C
Cong Wang 已提交
530
	rd->remote_ip = *ip;
531 532 533 534 535 536
	rd->remote_port = port;
	rd->remote_vni = vni;
	rd->remote_ifindex = ifindex;
	return 1;
}

537 538
/* Add/update destinations for multicast */
static int vxlan_fdb_append(struct vxlan_fdb *f,
C
Cong Wang 已提交
539
			    union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)
540 541 542 543 544 545 546
{
	struct vxlan_rdst *rd;

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

547 548 549
	rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
	if (rd == NULL)
		return -ENOBUFS;
C
Cong Wang 已提交
550
	rd->remote_ip = *ip;
551 552 553
	rd->remote_port = port;
	rd->remote_vni = vni;
	rd->remote_ifindex = ifindex;
554 555 556

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

557 558 559
	return 1;
}

S
stephen hemminger 已提交
560 561
/* Add new entry to forwarding table -- assumes lock held */
static int vxlan_fdb_create(struct vxlan_dev *vxlan,
C
Cong Wang 已提交
562
			    const u8 *mac, union vxlan_addr *ip,
563
			    __u16 state, __u16 flags,
564
			    __be16 port, __u32 vni, __u32 ifindex,
565
			    __u8 ndm_flags)
S
stephen hemminger 已提交
566 567 568 569
{
	struct vxlan_fdb *f;
	int notify = 0;

570
	f = __vxlan_find_mac(vxlan, mac);
S
stephen hemminger 已提交
571 572 573 574 575 576 577 578 579 580 581
	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;
		}
582 583 584 585 586
		if (f->flags != ndm_flags) {
			f->flags = ndm_flags;
			f->updated = jiffies;
			notify = 1;
		}
587 588 589 590 591 592 593 594 595 596 597 598 599
		if ((flags & NLM_F_REPLACE)) {
			/* Only change unicasts */
			if (!(is_multicast_ether_addr(f->eth_addr) ||
			     is_zero_ether_addr(f->eth_addr))) {
				int rc = vxlan_fdb_replace(f, ip, port, vni,
							   ifindex);

				if (rc < 0)
					return rc;
				notify |= rc;
			} else
				return -EOPNOTSUPP;
		}
600
		if ((flags & NLM_F_APPEND) &&
601 602
		    (is_multicast_ether_addr(f->eth_addr) ||
		     is_zero_ether_addr(f->eth_addr))) {
603 604 605 606 607 608
			int rc = vxlan_fdb_append(f, ip, port, vni, ifindex);

			if (rc < 0)
				return rc;
			notify |= rc;
		}
S
stephen hemminger 已提交
609 610 611 612 613 614 615
	} else {
		if (!(flags & NLM_F_CREATE))
			return -ENOENT;

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

616 617 618 619 620
		/* Disallow replace to add a multicast entry */
		if ((flags & NLM_F_REPLACE) &&
		    (is_multicast_ether_addr(mac) || is_zero_ether_addr(mac)))
			return -EOPNOTSUPP;

C
Cong Wang 已提交
621
		netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);
S
stephen hemminger 已提交
622 623 624 625 626 627
		f = kmalloc(sizeof(*f), GFP_ATOMIC);
		if (!f)
			return -ENOMEM;

		notify = 1;
		f->state = state;
628
		f->flags = ndm_flags;
S
stephen hemminger 已提交
629
		f->updated = f->used = jiffies;
630
		INIT_LIST_HEAD(&f->remotes);
S
stephen hemminger 已提交
631 632
		memcpy(f->eth_addr, mac, ETH_ALEN);

633 634
		vxlan_fdb_append(f, ip, port, vni, ifindex);

S
stephen hemminger 已提交
635 636 637 638 639 640 641 642 643 644 645
		++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 已提交
646
static void vxlan_fdb_free(struct rcu_head *head)
647 648
{
	struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);
649
	struct vxlan_rdst *rd, *nd;
650

651
	list_for_each_entry_safe(rd, nd, &f->remotes, list)
652 653 654 655
		kfree(rd);
	kfree(f);
}

S
stephen hemminger 已提交
656 657 658 659 660 661 662 663 664
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);
665
	call_rcu(&f->rcu, vxlan_fdb_free);
S
stephen hemminger 已提交
666 667
}

M
Mike Rapoport 已提交
668
static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,
C
Cong Wang 已提交
669
			   union vxlan_addr *ip, __be16 *port, u32 *vni, u32 *ifindex)
S
stephen hemminger 已提交
670
{
671
	struct net *net = dev_net(vxlan->dev);
C
Cong Wang 已提交
672
	int err;
S
stephen hemminger 已提交
673

M
Mike Rapoport 已提交
674
	if (tb[NDA_DST]) {
C
Cong Wang 已提交
675 676 677
		err = vxlan_nla_get_addr(ip, tb[NDA_DST]);
		if (err)
			return err;
M
Mike Rapoport 已提交
678
	} else {
C
Cong Wang 已提交
679 680 681 682 683 684 685 686 687 688
		union vxlan_addr *remote = &vxlan->default_dst.remote_ip;
		if (remote->sa.sa_family == AF_INET) {
			ip->sin.sin_addr.s_addr = htonl(INADDR_ANY);
			ip->sa.sa_family = AF_INET;
#if IS_ENABLED(CONFIG_IPV6)
		} else {
			ip->sin6.sin6_addr = in6addr_any;
			ip->sa.sa_family = AF_INET6;
#endif
		}
M
Mike Rapoport 已提交
689
	}
S
stephen hemminger 已提交
690

691
	if (tb[NDA_PORT]) {
692
		if (nla_len(tb[NDA_PORT]) != sizeof(__be16))
693
			return -EINVAL;
M
Mike Rapoport 已提交
694 695 696 697
		*port = nla_get_be16(tb[NDA_PORT]);
	} else {
		*port = vxlan->dst_port;
	}
698 699 700 701

	if (tb[NDA_VNI]) {
		if (nla_len(tb[NDA_VNI]) != sizeof(u32))
			return -EINVAL;
M
Mike Rapoport 已提交
702 703 704 705
		*vni = nla_get_u32(tb[NDA_VNI]);
	} else {
		*vni = vxlan->default_dst.remote_vni;
	}
706 707

	if (tb[NDA_IFINDEX]) {
P
Pravin B Shelar 已提交
708
		struct net_device *tdev;
709 710 711

		if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
			return -EINVAL;
M
Mike Rapoport 已提交
712 713
		*ifindex = nla_get_u32(tb[NDA_IFINDEX]);
		tdev = dev_get_by_index(net, *ifindex);
P
Pravin B Shelar 已提交
714
		if (!tdev)
715
			return -EADDRNOTAVAIL;
P
Pravin B Shelar 已提交
716
		dev_put(tdev);
M
Mike Rapoport 已提交
717 718 719 720 721 722 723 724 725 726 727 728 729 730
	} 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); */
C
Cong Wang 已提交
731
	union vxlan_addr ip;
M
Mike Rapoport 已提交
732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
	__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;
748

S
stephen hemminger 已提交
749
	spin_lock_bh(&vxlan->hash_lock);
C
Cong Wang 已提交
750
	err = vxlan_fdb_create(vxlan, addr, &ip, ndm->ndm_state, flags,
751
			       port, vni, ifindex, ndm->ndm_flags);
S
stephen hemminger 已提交
752 753 754 755 756 757
	spin_unlock_bh(&vxlan->hash_lock);

	return err;
}

/* Delete entry (via netlink) */
758 759
static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
			    struct net_device *dev,
S
stephen hemminger 已提交
760 761 762 763
			    const unsigned char *addr)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb *f;
764
	struct vxlan_rdst *rd = NULL;
C
Cong Wang 已提交
765
	union vxlan_addr ip;
766 767 768 769 770 771 772 773 774
	__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 已提交
775 776 777

	spin_lock_bh(&vxlan->hash_lock);
	f = vxlan_find_mac(vxlan, addr);
778 779 780
	if (!f)
		goto out;

C
Cong Wang 已提交
781 782
	if (!vxlan_addr_any(&ip)) {
		rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);
783 784 785 786 787 788 789 790 791 792 793
		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);
794
		kfree_rcu(rd, rcu);
795
		goto out;
S
stephen hemminger 已提交
796
	}
797 798 799 800

	vxlan_fdb_destroy(vxlan, f);

out:
S
stephen hemminger 已提交
801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
	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;

817
		hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
818 819
			struct vxlan_rdst *rd;

820 821 822 823
			if (idx < cb->args[0])
				goto skip;

			list_for_each_entry_rcu(rd, &f->remotes, list) {
824 825 826 827 828 829
				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)
830
					goto out;
831
			}
832 833
skip:
			++idx;
S
stephen hemminger 已提交
834 835
		}
	}
836
out:
S
stephen hemminger 已提交
837 838 839 840 841
	return idx;
}

/* Watch incoming packets to learn mapping between Ethernet address
 * and Tunnel endpoint.
842
 * Return true if packet is bogus and should be droppped.
S
stephen hemminger 已提交
843
 */
844
static bool vxlan_snoop(struct net_device *dev,
C
Cong Wang 已提交
845
			union vxlan_addr *src_ip, const u8 *src_mac)
S
stephen hemminger 已提交
846 847 848 849 850 851
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_fdb *f;

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

C
Cong Wang 已提交
854
		if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip)))
855 856 857
			return false;

		/* Don't migrate static entries, drop packets */
858
		if (f->state & NUD_NOARP)
859
			return true;
S
stephen hemminger 已提交
860 861 862

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

C
Cong Wang 已提交
866
		rdst->remote_ip = *src_ip;
S
stephen hemminger 已提交
867
		f->updated = jiffies;
868
		vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);
S
stephen hemminger 已提交
869 870 871
	} else {
		/* learned new entry */
		spin_lock(&vxlan->hash_lock);
872 873 874 875 876 877 878 879 880

		/* 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 已提交
881 882
		spin_unlock(&vxlan->hash_lock);
	}
883 884

	return false;
S
stephen hemminger 已提交
885 886 887
}

/* See if multicast group is already in use by other ID */
C
Cong Wang 已提交
888
static bool vxlan_group_used(struct vxlan_net *vn, union vxlan_addr *remote_ip)
S
stephen hemminger 已提交
889
{
890
	struct vxlan_dev *vxlan;
S
stephen hemminger 已提交
891

892 893 894
	list_for_each_entry(vxlan, &vn->vxlan_list, next) {
		if (!netif_running(vxlan->dev))
			continue;
S
stephen hemminger 已提交
895

C
Cong Wang 已提交
896 897
		if (vxlan_addr_equal(&vxlan->default_dst.remote_ip,
				     remote_ip))
898 899
			return true;
	}
S
stephen hemminger 已提交
900 901 902 903

	return false;
}

904
static void vxlan_sock_hold(struct vxlan_sock *vs)
S
stephen hemminger 已提交
905
{
906 907
	atomic_inc(&vs->refcnt);
}
S
stephen hemminger 已提交
908

909
void vxlan_sock_release(struct vxlan_sock *vs)
910
{
911 912
	struct vxlan_net *vn = net_generic(sock_net(vs->sock->sk), vxlan_net_id);

913 914
	if (!atomic_dec_and_test(&vs->refcnt))
		return;
S
stephen hemminger 已提交
915

916
	spin_lock(&vn->sock_lock);
917
	hlist_del_rcu(&vs->hlist);
918 919
	spin_unlock(&vn->sock_lock);

920
	queue_work(vxlan_wq, &vs->del_work);
S
stephen hemminger 已提交
921
}
922
EXPORT_SYMBOL_GPL(vxlan_sock_release);
S
stephen hemminger 已提交
923

S
stephen hemminger 已提交
924 925 926
/* Callback to update multicast group membership when first VNI on
 * multicast asddress is brought up
 * Done as workqueue because ip_mc_join_group acquires RTNL.
927
 */
S
stephen hemminger 已提交
928
static void vxlan_igmp_join(struct work_struct *work)
S
stephen hemminger 已提交
929
{
S
stephen hemminger 已提交
930
	struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_join);
931 932
	struct vxlan_sock *vs = vxlan->vn_sock;
	struct sock *sk = vs->sock->sk;
C
Cong Wang 已提交
933 934
	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
	int ifindex = vxlan->default_dst.remote_ifindex;
S
stephen hemminger 已提交
935 936

	lock_sock(sk);
C
Cong Wang 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949
	if (ip->sa.sa_family == AF_INET) {
		struct ip_mreqn mreq = {
			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
			.imr_ifindex		= ifindex,
		};

		ip_mc_join_group(sk, &mreq);
#if IS_ENABLED(CONFIG_IPV6)
	} else {
		ipv6_stub->ipv6_sock_mc_join(sk, ifindex,
					     &ip->sin6.sin6_addr);
#endif
	}
S
stephen hemminger 已提交
950 951
	release_sock(sk);

952
	vxlan_sock_release(vs);
S
stephen hemminger 已提交
953 954 955 956 957 958 959 960 961
	dev_put(vxlan->dev);
}

/* Inverse of vxlan_igmp_join when last VNI is brought down */
static void vxlan_igmp_leave(struct work_struct *work)
{
	struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_leave);
	struct vxlan_sock *vs = vxlan->vn_sock;
	struct sock *sk = vs->sock->sk;
C
Cong Wang 已提交
962 963
	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
	int ifindex = vxlan->default_dst.remote_ifindex;
S
stephen hemminger 已提交
964 965

	lock_sock(sk);
C
Cong Wang 已提交
966 967 968 969 970 971 972 973 974 975 976 977 978 979
	if (ip->sa.sa_family == AF_INET) {
		struct ip_mreqn mreq = {
			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
			.imr_ifindex		= ifindex,
		};

		ip_mc_leave_group(sk, &mreq);
#if IS_ENABLED(CONFIG_IPV6)
	} else {
		ipv6_stub->ipv6_sock_mc_drop(sk, ifindex,
					     &ip->sin6.sin6_addr);
#endif
	}

S
stephen hemminger 已提交
980 981
	release_sock(sk);

982
	vxlan_sock_release(vs);
983
	dev_put(vxlan->dev);
S
stephen hemminger 已提交
984 985 986 987 988
}

/* Callback from net/ipv4/udp.c to receive packets */
static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
{
P
Pravin B Shelar 已提交
989
	struct vxlan_sock *vs;
S
stephen hemminger 已提交
990
	struct vxlanhdr *vxh;
991
	__be16 port;
S
stephen hemminger 已提交
992 993

	/* Need Vxlan and inner Ethernet header to be present */
994
	if (!pskb_may_pull(skb, VXLAN_HLEN))
S
stephen hemminger 已提交
995 996
		goto error;

997 998
	/* Return packets with reserved bits set */
	vxh = (struct vxlanhdr *)(udp_hdr(skb) + 1);
S
stephen hemminger 已提交
999 1000 1001 1002 1003 1004 1005
	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;
	}

P
Pravin B Shelar 已提交
1006 1007 1008
	if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB)))
		goto drop;

1009
	port = inet_sk(sk)->inet_sport;
P
Pravin B Shelar 已提交
1010 1011 1012

	vs = vxlan_find_sock(sock_net(sk), port);
	if (!vs)
S
stephen hemminger 已提交
1013 1014
		goto drop;

P
Pravin B Shelar 已提交
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
	vs->rcv(vs, skb, vxh->vx_vni);
	return 0;

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

error:
	/* Return non vxlan pkt */
	return 1;
}

static void vxlan_rcv(struct vxlan_sock *vs,
		      struct sk_buff *skb, __be32 vx_vni)
{
C
Cong Wang 已提交
1031 1032
	struct iphdr *oip = NULL;
	struct ipv6hdr *oip6 = NULL;
P
Pravin B Shelar 已提交
1033 1034
	struct vxlan_dev *vxlan;
	struct pcpu_tstats *stats;
C
Cong Wang 已提交
1035
	union vxlan_addr saddr;
P
Pravin B Shelar 已提交
1036
	__u32 vni;
C
Cong Wang 已提交
1037 1038
	int err = 0;
	union vxlan_addr *remote_ip;
P
Pravin B Shelar 已提交
1039 1040 1041 1042 1043

	vni = ntohl(vx_vni) >> 8;
	/* Is this VNI defined? */
	vxlan = vxlan_vs_find_vni(vs, vni);
	if (!vxlan)
S
stephen hemminger 已提交
1044 1045
		goto drop;

C
Cong Wang 已提交
1046
	remote_ip = &vxlan->default_dst.remote_ip;
D
David Stevens 已提交
1047
	skb_reset_mac_header(skb);
S
stephen hemminger 已提交
1048 1049 1050 1051 1052 1053 1054
	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;

1055
	/* Re-examine inner Ethernet packet */
C
Cong Wang 已提交
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
	if (remote_ip->sa.sa_family == AF_INET) {
		oip = ip_hdr(skb);
		saddr.sin.sin_addr.s_addr = oip->saddr;
		saddr.sa.sa_family = AF_INET;
#if IS_ENABLED(CONFIG_IPV6)
	} else {
		oip6 = ipv6_hdr(skb);
		saddr.sin6.sin6_addr = oip6->saddr;
		saddr.sa.sa_family = AF_INET6;
#endif
	}

1068
	if ((vxlan->flags & VXLAN_F_LEARN) &&
C
Cong Wang 已提交
1069
	    vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source))
1070
		goto drop;
S
stephen hemminger 已提交
1071 1072

	skb_reset_network_header(skb);
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083

	/* 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 已提交
1084

C
Cong Wang 已提交
1085 1086 1087 1088 1089
	if (oip6)
		err = IP6_ECN_decapsulate(oip6, skb);
	if (oip)
		err = IP_ECN_decapsulate(oip, skb);

S
stephen hemminger 已提交
1090
	if (unlikely(err)) {
C
Cong Wang 已提交
1091 1092 1093 1094 1095 1096 1097 1098
		if (log_ecn_error) {
			if (oip6)
				net_info_ratelimited("non-ECT from %pI6\n",
						     &oip6->saddr);
			if (oip)
				net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
						     &oip->saddr, oip->tos);
		}
S
stephen hemminger 已提交
1099 1100 1101 1102 1103 1104 1105
		if (err > 1) {
			++vxlan->dev->stats.rx_frame_errors;
			++vxlan->dev->stats.rx_errors;
			goto drop;
		}
	}

1106
	stats = this_cpu_ptr(vxlan->dev->tstats);
S
stephen hemminger 已提交
1107 1108 1109 1110 1111 1112 1113
	u64_stats_update_begin(&stats->syncp);
	stats->rx_packets++;
	stats->rx_bytes += skb->len;
	u64_stats_update_end(&stats->syncp);

	netif_rx(skb);

P
Pravin B Shelar 已提交
1114
	return;
S
stephen hemminger 已提交
1115 1116 1117 1118 1119
drop:
	/* Consume bad packet */
	kfree_skb(skb);
}

D
David Stevens 已提交
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
static int arp_reduce(struct net_device *dev, struct sk_buff *skb)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct arphdr *parp;
	u8 *arpptr, *sha;
	__be32 sip, tip;
	struct neighbour *n;

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

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

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

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

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

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

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

		f = vxlan_find_mac(vxlan, n->ha);
C
Cong Wang 已提交
1168
		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
D
David Stevens 已提交
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
			/* 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++;
C
Cong Wang 已提交
1186 1187 1188 1189 1190 1191 1192 1193
	} else if (vxlan->flags & VXLAN_F_L3MISS) {
		union vxlan_addr ipa = {
			.sin.sin_addr.s_addr = tip,
			.sa.sa_family = AF_INET,
		};

		vxlan_ip_miss(dev, &ipa);
	}
D
David Stevens 已提交
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
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;

	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:
1210 1211 1212
	{
		struct iphdr *pip;

D
David Stevens 已提交
1213 1214 1215 1216
		if (!pskb_may_pull(skb, sizeof(struct iphdr)))
			return false;
		pip = ip_hdr(skb);
		n = neigh_lookup(&arp_tbl, &pip->daddr, dev);
C
Cong Wang 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
		if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
			union vxlan_addr ipa = {
				.sin.sin_addr.s_addr = pip->daddr,
				.sa.sa_family = AF_INET,
			};

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

D
David Stevens 已提交
1227
		break;
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
	}
#if IS_ENABLED(CONFIG_IPV6)
	case ETH_P_IPV6:
	{
		struct ipv6hdr *pip6;

		if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
			return false;
		pip6 = ipv6_hdr(skb);
		n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev);
		if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
			union vxlan_addr ipa = {
				.sin6.sin6_addr = pip6->daddr,
				.sa.sa_family = AF_INET6,
			};

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

		break;
	}
#endif
D
David Stevens 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
	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;
C
Cong Wang 已提交
1266 1267
	}

D
David Stevens 已提交
1268 1269 1270
	return false;
}

1271
static void vxlan_sock_put(struct sk_buff *skb)
1272 1273 1274 1275 1276
{
	sock_put(skb->sk);
}

/* On transmit, associate with the tunnel socket */
1277
static void vxlan_set_owner(struct sock *sk, struct sk_buff *skb)
1278 1279 1280 1281
{
	skb_orphan(skb);
	sock_hold(sk);
	skb->sk = sk;
1282
	skb->destructor = vxlan_sock_put;
1283 1284
}

1285 1286 1287 1288 1289
/* 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
 */
1290
__be16 vxlan_src_port(__u16 port_min, __u16 port_max, struct sk_buff *skb)
1291
{
1292
	unsigned int range = (port_max - port_min) + 1;
1293 1294 1295 1296 1297 1298 1299
	u32 hash;

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

1300
	return htons((((u64) hash * range) >> 32) + port_min);
1301
}
1302
EXPORT_SYMBOL_GPL(vxlan_src_port);
1303

1304 1305 1306 1307 1308 1309 1310
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 已提交
1311
		skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
1312 1313 1314 1315 1316 1317
	} else if (skb->ip_summed != CHECKSUM_PARTIAL)
		skb->ip_summed = CHECKSUM_NONE;

	return 0;
}

C
Cong Wang 已提交
1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
#if IS_ENABLED(CONFIG_IPV6)
static int vxlan6_xmit_skb(struct net *net, struct vxlan_sock *vs,
			   struct dst_entry *dst, struct sk_buff *skb,
			   struct net_device *dev, struct in6_addr *saddr,
			   struct in6_addr *daddr, __u8 prio, __u8 ttl,
			   __be16 src_port, __be16 dst_port, __be32 vni)
{
	struct ipv6hdr *ip6h;
	struct vxlanhdr *vxh;
	struct udphdr *uh;
	int min_headroom;
	int err;

	if (!skb->encapsulation) {
		skb_reset_inner_headers(skb);
		skb->encapsulation = 1;
	}

	min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len
			+ VXLAN_HLEN + sizeof(struct ipv6hdr)
			+ (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);

	/* Need space for new headers (invalidates iph ptr) */
	err = skb_cow_head(skb, min_headroom);
	if (unlikely(err))
		return err;

	if (vlan_tx_tag_present(skb)) {
		if (WARN_ON(!__vlan_put_tag(skb,
					    skb->vlan_proto,
					    vlan_tx_tag_get(skb))))
			return -ENOMEM;

		skb->vlan_tci = 0;
	}

	vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
	vxh->vx_flags = htonl(VXLAN_FLAGS);
	vxh->vx_vni = vni;

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

	uh->dest = dst_port;
	uh->source = src_port;

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

	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
			      IPSKB_REROUTED);
	skb_dst_drop(skb);
	skb_dst_set(skb, dst);

	if (!skb_is_gso(skb) && !(dst->dev->features & NETIF_F_IPV6_CSUM)) {
		__wsum csum = skb_checksum(skb, 0, skb->len, 0);
		skb->ip_summed = CHECKSUM_UNNECESSARY;
		uh->check = csum_ipv6_magic(saddr, daddr, skb->len,
					    IPPROTO_UDP, csum);
		if (uh->check == 0)
			uh->check = CSUM_MANGLED_0;
	} else {
		skb->ip_summed = CHECKSUM_PARTIAL;
		skb->csum_start = skb_transport_header(skb) - skb->head;
		skb->csum_offset = offsetof(struct udphdr, check);
		uh->check = ~csum_ipv6_magic(saddr, daddr,
					     skb->len, IPPROTO_UDP, 0);
	}

	__skb_push(skb, sizeof(*ip6h));
	skb_reset_network_header(skb);
	ip6h		  = ipv6_hdr(skb);
	ip6h->version	  = 6;
	ip6h->priority	  = prio;
	ip6h->flow_lbl[0] = 0;
	ip6h->flow_lbl[1] = 0;
	ip6h->flow_lbl[2] = 0;
	ip6h->payload_len = htons(skb->len);
	ip6h->nexthdr     = IPPROTO_UDP;
	ip6h->hop_limit   = ttl;
	ip6h->daddr	  = *daddr;
	ip6h->saddr	  = *saddr;

	vxlan_set_owner(vs->sock->sk, skb);

	err = handle_offloads(skb);
	if (err)
		return err;

	ip6tunnel_xmit(skb, dev);
	return 0;
}
#endif

1414 1415 1416 1417 1418 1419 1420
int vxlan_xmit_skb(struct net *net, struct vxlan_sock *vs,
		   struct rtable *rt, struct sk_buff *skb,
		   __be32 src, __be32 dst, __u8 tos, __u8 ttl, __be16 df,
		   __be16 src_port, __be16 dst_port, __be32 vni)
{
	struct vxlanhdr *vxh;
	struct udphdr *uh;
1421
	int min_headroom;
1422 1423 1424 1425 1426 1427 1428
	int err;

	if (!skb->encapsulation) {
		skb_reset_inner_headers(skb);
		skb->encapsulation = 1;
	}

1429
	min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
1430 1431
			+ VXLAN_HLEN + sizeof(struct iphdr)
			+ (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);
1432 1433 1434 1435 1436 1437

	/* Need space for new headers (invalidates iph ptr) */
	err = skb_cow_head(skb, min_headroom);
	if (unlikely(err))
		return err;

1438 1439 1440 1441 1442 1443 1444 1445 1446
	if (vlan_tx_tag_present(skb)) {
		if (WARN_ON(!__vlan_put_tag(skb,
					    skb->vlan_proto,
					    vlan_tx_tag_get(skb))))
			return -ENOMEM;

		skb->vlan_tci = 0;
	}

1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
	vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
	vxh->vx_flags = htonl(VXLAN_FLAGS);
	vxh->vx_vni = vni;

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

	uh->dest = dst_port;
	uh->source = src_port;

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

	vxlan_set_owner(vs->sock->sk, skb);

	err = handle_offloads(skb);
	if (err)
		return err;

	return iptunnel_xmit(net, rt, skb, src, dst,
			IPPROTO_UDP, tos, ttl, df);
}
EXPORT_SYMBOL_GPL(vxlan_xmit_skb);

1472 1473 1474 1475 1476 1477
/* 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);
C
Cong Wang 已提交
1478 1479
	union vxlan_addr loopback;
	union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;
1480 1481 1482 1483 1484 1485

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

C
Cong Wang 已提交
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
	if (remote_ip->sa.sa_family == AF_INET) {
		loopback.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
		loopback.sa.sa_family =  AF_INET;
#if IS_ENABLED(CONFIG_IPV6)
	} else {
		loopback.sin6.sin6_addr = in6addr_loopback;
		loopback.sa.sa_family =  AF_INET6;
#endif
	}

1496
	if (dst_vxlan->flags & VXLAN_F_LEARN)
C
Cong Wang 已提交
1497
		vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source);
1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513

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

1514 1515
static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
			   struct vxlan_rdst *rdst, bool did_rsc)
S
stephen hemminger 已提交
1516 1517
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
C
Cong Wang 已提交
1518
	struct rtable *rt = NULL;
S
stephen hemminger 已提交
1519 1520
	const struct iphdr *old_iph;
	struct flowi4 fl4;
C
Cong Wang 已提交
1521 1522
	union vxlan_addr *dst;
	__be16 src_port = 0, dst_port;
S
Stephen Hemminger 已提交
1523
	u32 vni;
S
stephen hemminger 已提交
1524 1525
	__be16 df = 0;
	__u8 tos, ttl;
1526
	int err;
S
stephen hemminger 已提交
1527

1528
	dst_port = rdst->remote_port ? rdst->remote_port : vxlan->dst_port;
1529
	vni = rdst->remote_vni;
C
Cong Wang 已提交
1530
	dst = &rdst->remote_ip;
D
David Stevens 已提交
1531

C
Cong Wang 已提交
1532
	if (vxlan_addr_any(dst)) {
D
David Stevens 已提交
1533 1534
		if (did_rsc) {
			/* short-circuited back to local bridge */
1535
			vxlan_encap_bypass(skb, vxlan, vxlan);
1536
			return;
D
David Stevens 已提交
1537
		}
1538
		goto drop;
D
David Stevens 已提交
1539
	}
1540

S
stephen hemminger 已提交
1541 1542 1543
	old_iph = ip_hdr(skb);

	ttl = vxlan->ttl;
C
Cong Wang 已提交
1544
	if (!ttl && vxlan_addr_multicast(dst))
S
stephen hemminger 已提交
1545 1546 1547 1548
		ttl = 1;

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

1551
	src_port = vxlan_src_port(vxlan->port_min, vxlan->port_max, skb);
S
stephen hemminger 已提交
1552

C
Cong Wang 已提交
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566
	if (dst->sa.sa_family == AF_INET) {
		memset(&fl4, 0, sizeof(fl4));
		fl4.flowi4_oif = rdst->remote_ifindex;
		fl4.flowi4_tos = RT_TOS(tos);
		fl4.daddr = dst->sin.sin_addr.s_addr;
		fl4.saddr = vxlan->saddr.sin.sin_addr.s_addr;

		rt = ip_route_output_key(dev_net(dev), &fl4);
		if (IS_ERR(rt)) {
			netdev_dbg(dev, "no route to %pI4\n",
				   &dst->sin.sin_addr.s_addr);
			dev->stats.tx_carrier_errors++;
			goto tx_error;
		}
S
stephen hemminger 已提交
1567

C
Cong Wang 已提交
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
		if (rt->dst.dev == dev) {
			netdev_dbg(dev, "circular route to %pI4\n",
				   &dst->sin.sin_addr.s_addr);
			dev->stats.collisions++;
			goto tx_error;
		}

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

			ip_rt_put(rt);
			dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);
			if (!dst_vxlan)
				goto tx_error;
			vxlan_encap_bypass(skb, vxlan, dst_vxlan);
			return;
		}

		tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
		ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
S
stephen hemminger 已提交
1590

C
Cong Wang 已提交
1591 1592 1593 1594
		err = vxlan_xmit_skb(dev_net(dev), vxlan->vn_sock, rt, skb,
				     fl4.saddr, dst->sin.sin_addr.s_addr,
				     tos, ttl, df, src_port, dst_port,
				     htonl(vni << 8));
1595

C
Cong Wang 已提交
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
		if (err < 0)
			goto rt_tx_error;
		iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
#if IS_ENABLED(CONFIG_IPV6)
	} else {
		struct sock *sk = vxlan->vn_sock->sock->sk;
		struct dst_entry *ndst;
		struct flowi6 fl6;
		u32 flags;

		memset(&fl6, 0, sizeof(fl6));
		fl6.flowi6_oif = rdst->remote_ifindex;
		fl6.daddr = dst->sin6.sin6_addr;
		fl6.saddr = vxlan->saddr.sin6.sin6_addr;
		fl6.flowi6_proto = skb->protocol;

		if (ipv6_stub->ipv6_dst_lookup(sk, &ndst, &fl6)) {
			netdev_dbg(dev, "no route to %pI6\n",
				   &dst->sin6.sin6_addr);
			dev->stats.tx_carrier_errors++;
1616
			goto tx_error;
C
Cong Wang 已提交
1617
		}
S
stephen hemminger 已提交
1618

C
Cong Wang 已提交
1619 1620 1621 1622 1623 1624 1625
		if (ndst->dev == dev) {
			netdev_dbg(dev, "circular route to %pI6\n",
				   &dst->sin6.sin6_addr);
			dst_release(ndst);
			dev->stats.collisions++;
			goto tx_error;
		}
1626

C
Cong Wang 已提交
1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
		/* Bypass encapsulation if the destination is local */
		flags = ((struct rt6_info *)ndst)->rt6i_flags;
		if (flags & RTF_LOCAL &&
		    !(flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
			struct vxlan_dev *dst_vxlan;

			dst_release(ndst);
			dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);
			if (!dst_vxlan)
				goto tx_error;
			vxlan_encap_bypass(skb, vxlan, dst_vxlan);
			return;
		}
1640

C
Cong Wang 已提交
1641 1642 1643 1644 1645 1646 1647
		ttl = ttl ? : ip6_dst_hoplimit(ndst);

		err = vxlan6_xmit_skb(dev_net(dev), vxlan->vn_sock, ndst, skb,
				      dev, &fl6.saddr, &fl6.daddr, 0, ttl,
				      src_port, dst_port, htonl(vni << 8));
#endif
	}
1648

1649
	return;
S
stephen hemminger 已提交
1650 1651 1652 1653 1654

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

1655 1656
rt_tx_error:
	ip_rt_put(rt);
S
stephen hemminger 已提交
1657 1658 1659 1660 1661 1662
tx_error:
	dev->stats.tx_errors++;
tx_free:
	dev_kfree_skb(skb);
}

1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
/* 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;
1674
	struct vxlan_rdst *rdst;
1675 1676 1677 1678 1679 1680 1681 1682 1683
	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);
1684 1685 1686
	did_rsc = false;

	if (f && (f->flags & NTF_ROUTER) && (vxlan->flags & VXLAN_F_RSC) &&
1687 1688
	    (ntohs(eth->h_proto) == ETH_P_IP ||
	     ntohs(eth->h_proto) == ETH_P_IPV6)) {
1689 1690 1691 1692 1693
		did_rsc = route_shortcircuit(dev, skb);
		if (did_rsc)
			f = vxlan_find_mac(vxlan, eth->h_dest);
	}

1694
	if (f == NULL) {
1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
		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;
		}
	}
1706

1707 1708
	list_for_each_entry_rcu(rdst, &f->remotes, list) {
		struct sk_buff *skb1;
1709

1710 1711 1712
		skb1 = skb_clone(skb, GFP_ATOMIC);
		if (skb1)
			vxlan_xmit_one(skb1, dev, rdst, did_rsc);
1713 1714
	}

1715
	dev_kfree_skb(skb);
1716
	return NETDEV_TX_OK;
1717 1718
}

S
stephen hemminger 已提交
1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
/* 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;

1737
			if (f->state & NUD_PERMANENT)
S
stephen hemminger 已提交
1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755
				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);
}

1756 1757 1758 1759 1760 1761 1762 1763
static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan)
{
	__u32 vni = vxlan->default_dst.remote_vni;

	vxlan->vn_sock = vs;
	hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));
}

S
stephen hemminger 已提交
1764 1765 1766
/* Setup stats when device is created */
static int vxlan_init(struct net_device *dev)
{
1767 1768 1769 1770
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
	struct vxlan_sock *vs;

1771 1772
	dev->tstats = alloc_percpu(struct pcpu_tstats);
	if (!dev->tstats)
S
stephen hemminger 已提交
1773 1774
		return -ENOMEM;

1775
	spin_lock(&vn->sock_lock);
1776
	vs = vxlan_find_sock(dev_net(dev), vxlan->dst_port);
1777 1778 1779
	if (vs) {
		/* If we have a socket with same port already, reuse it */
		atomic_inc(&vs->refcnt);
1780
		vxlan_vs_add_dev(vs, vxlan);
1781 1782 1783 1784 1785 1786 1787
	} 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 已提交
1788 1789 1790
	return 0;
}

1791
static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan)
1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
{
	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);
}

1802 1803 1804 1805 1806
static void vxlan_uninit(struct net_device *dev)
{
	struct vxlan_dev *vxlan = netdev_priv(dev);
	struct vxlan_sock *vs = vxlan->vn_sock;

1807
	vxlan_fdb_delete_default(vxlan);
1808

1809
	if (vs)
1810
		vxlan_sock_release(vs);
1811 1812 1813
	free_percpu(dev->tstats);
}

S
stephen hemminger 已提交
1814 1815 1816
/* Start ageing timer and join group when device is brought up */
static int vxlan_open(struct net_device *dev)
{
S
stephen hemminger 已提交
1817
	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
S
stephen hemminger 已提交
1818
	struct vxlan_dev *vxlan = netdev_priv(dev);
1819 1820 1821 1822 1823
	struct vxlan_sock *vs = vxlan->vn_sock;

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

C
Cong Wang 已提交
1825 1826
	if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&
	    vxlan_group_used(vn, &vxlan->default_dst.remote_ip)) {
1827
		vxlan_sock_hold(vs);
1828
		dev_hold(dev);
S
stephen hemminger 已提交
1829
		queue_work(vxlan_wq, &vxlan->igmp_join);
S
stephen hemminger 已提交
1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
	}

	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)
{
1841
	unsigned int h;
S
stephen hemminger 已提交
1842 1843 1844 1845 1846 1847 1848

	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);
1849 1850 1851
			/* 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 已提交
1852 1853 1854 1855 1856 1857 1858 1859
		}
	}
	spin_unlock_bh(&vxlan->hash_lock);
}

/* Cleanup timer and forwarding table on shutdown */
static int vxlan_stop(struct net_device *dev)
{
S
stephen hemminger 已提交
1860
	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
S
stephen hemminger 已提交
1861
	struct vxlan_dev *vxlan = netdev_priv(dev);
1862
	struct vxlan_sock *vs = vxlan->vn_sock;
S
stephen hemminger 已提交
1863

C
Cong Wang 已提交
1864 1865
	if (vs && vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&
	    ! vxlan_group_used(vn, &vxlan->default_dst.remote_ip)) {
1866
		vxlan_sock_hold(vs);
1867
		dev_hold(dev);
S
stephen hemminger 已提交
1868
		queue_work(vxlan_wq, &vxlan->igmp_leave);
1869
	}
S
stephen hemminger 已提交
1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884

	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,
1885
	.ndo_uninit		= vxlan_uninit,
S
stephen hemminger 已提交
1886 1887 1888
	.ndo_open		= vxlan_open,
	.ndo_stop		= vxlan_stop,
	.ndo_start_xmit		= vxlan_xmit,
1889
	.ndo_get_stats64	= ip_tunnel_get_stats64,
S
stephen hemminger 已提交
1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
	.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);
1908
	unsigned int h;
1909
	int low, high;
S
stephen hemminger 已提交
1910 1911 1912

	eth_hw_addr_random(dev);
	ether_setup(dev);
C
Cong Wang 已提交
1913 1914 1915 1916
	if (vxlan->default_dst.remote_ip.sa.sa_family == AF_INET6)
		dev->hard_header_len = ETH_HLEN + VXLAN6_HEADROOM;
	else
		dev->hard_header_len = ETH_HLEN + VXLAN_HEADROOM;
S
stephen hemminger 已提交
1917 1918

	dev->netdev_ops = &vxlan_netdev_ops;
1919
	dev->destructor = free_netdev;
S
stephen hemminger 已提交
1920 1921 1922 1923 1924
	SET_NETDEV_DEVTYPE(dev, &vxlan_type);

	dev->tx_queue_len = 0;
	dev->features	|= NETIF_F_LLTX;
	dev->features	|= NETIF_F_NETNS_LOCAL;
1925
	dev->features	|= NETIF_F_SG | NETIF_F_HW_CSUM;
1926
	dev->features   |= NETIF_F_RXCSUM;
1927
	dev->features   |= NETIF_F_GSO_SOFTWARE;
1928

1929 1930
	dev->vlan_features = dev->features;
	dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
1931
	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1932
	dev->hw_features |= NETIF_F_GSO_SOFTWARE;
1933
	dev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
S
stephen hemminger 已提交
1934
	dev->priv_flags	&= ~IFF_XMIT_DST_RELEASE;
1935
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
S
stephen hemminger 已提交
1936

1937
	INIT_LIST_HEAD(&vxlan->next);
S
stephen hemminger 已提交
1938
	spin_lock_init(&vxlan->hash_lock);
S
stephen hemminger 已提交
1939 1940
	INIT_WORK(&vxlan->igmp_join, vxlan_igmp_join);
	INIT_WORK(&vxlan->igmp_leave, vxlan_igmp_leave);
1941
	INIT_WORK(&vxlan->sock_work, vxlan_sock_work);
S
stephen hemminger 已提交
1942 1943 1944 1945 1946

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

1947 1948 1949
	inet_get_local_port_range(&low, &high);
	vxlan->port_min = low;
	vxlan->port_max = high;
1950
	vxlan->dst_port = htons(vxlan_port);
1951

S
stephen hemminger 已提交
1952 1953 1954 1955 1956 1957 1958 1959
	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 },
1960
	[IFLA_VXLAN_GROUP]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
C
Cong Wang 已提交
1961
	[IFLA_VXLAN_GROUP6]	= { .len = sizeof(struct in6_addr) },
S
stephen hemminger 已提交
1962 1963
	[IFLA_VXLAN_LINK]	= { .type = NLA_U32 },
	[IFLA_VXLAN_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
C
Cong Wang 已提交
1964
	[IFLA_VXLAN_LOCAL6]	= { .len = sizeof(struct in6_addr) },
S
stephen hemminger 已提交
1965 1966 1967 1968 1969
	[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 },
1970
	[IFLA_VXLAN_PORT_RANGE] = { .len  = sizeof(struct ifla_vxlan_port_range) },
D
David Stevens 已提交
1971 1972 1973 1974
	[IFLA_VXLAN_PROXY]	= { .type = NLA_U8 },
	[IFLA_VXLAN_RSC]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L2MISS]	= { .type = NLA_U8 },
	[IFLA_VXLAN_L3MISS]	= { .type = NLA_U8 },
1975
	[IFLA_VXLAN_PORT]	= { .type = NLA_U16 },
S
stephen hemminger 已提交
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
};

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

2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011
	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 已提交
2012 2013 2014
	return 0;
}

Y
Yan Burman 已提交
2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
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,
};

2027 2028 2029 2030 2031 2032 2033 2034
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);
}

C
Cong Wang 已提交
2035 2036 2037 2038 2039 2040
#if IS_ENABLED(CONFIG_IPV6)
/* Create UDP socket for encapsulation receive. AF_INET6 socket
 * could be used for both IPv4 and IPv6 communications, but
 * users may set bindv6only=1.
 */
static int create_v6_sock(struct net *net, __be16 port, struct socket **psock)
2041 2042
{
	struct sock *sk;
C
Cong Wang 已提交
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092
	struct socket *sock;
	struct sockaddr_in6 vxlan_addr = {
		.sin6_family = AF_INET6,
		.sin6_port = port,
	};
	int rc, val = 1;

	rc = sock_create_kern(AF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);
	if (rc < 0) {
		pr_debug("UDPv6 socket create failed\n");
		return rc;
	}

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

	kernel_setsockopt(sock, SOL_IPV6, IPV6_V6ONLY,
			  (char *)&val, sizeof(val));
	rc = kernel_bind(sock, (struct sockaddr *)&vxlan_addr,
			 sizeof(struct sockaddr_in6));
	if (rc < 0) {
		pr_debug("bind for UDPv6 socket %pI6:%u (%d)\n",
			 &vxlan_addr.sin6_addr, ntohs(vxlan_addr.sin6_port), rc);
		sk_release_kernel(sk);
		return rc;
	}
	/* At this point, IPv6 module should have been loaded in
	 * sock_create_kern().
	 */
	BUG_ON(!ipv6_stub);

	*psock = sock;
	/* Disable multicast loopback */
	inet_sk(sk)->mc_loop = 0;
	return 0;
}

#else

static int create_v6_sock(struct net *net, __be16 port, struct socket **psock)
{
		return -EPFNOSUPPORT;
}
#endif

static int create_v4_sock(struct net *net, __be16 port, struct socket **psock)
{
	struct sock *sk;
	struct socket *sock;
2093 2094 2095
	struct sockaddr_in vxlan_addr = {
		.sin_family = AF_INET,
		.sin_addr.s_addr = htonl(INADDR_ANY),
2096
		.sin_port = port,
2097 2098 2099 2100
	};
	int rc;

	/* Create UDP socket for encapsulation receive. */
C
Cong Wang 已提交
2101
	rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
2102 2103
	if (rc < 0) {
		pr_debug("UDP socket create failed\n");
C
Cong Wang 已提交
2104
		return rc;
2105 2106 2107
	}

	/* Put in proper namespace */
C
Cong Wang 已提交
2108
	sk = sock->sk;
2109 2110
	sk_change_net(sk, net);

C
Cong Wang 已提交
2111
	rc = kernel_bind(sock, (struct sockaddr *) &vxlan_addr,
2112 2113 2114 2115 2116
			 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);
C
Cong Wang 已提交
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
		return rc;
	}

	*psock = sock;
	/* Disable multicast loopback */
	inet_sk(sk)->mc_loop = 0;
	return 0;
}

/* Create new listen socket if needed */
static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port,
					      vxlan_rcv_t *rcv, void *data, bool ipv6)
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
	struct vxlan_sock *vs;
	struct socket *sock;
	struct sock *sk;
	int rc = 0;
	unsigned int h;

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

	if (ipv6)
		rc = create_v6_sock(net, port, &sock);
	else
		rc = create_v4_sock(net, port, &sock);
	if (rc < 0) {
2151 2152 2153
		kfree(vs);
		return ERR_PTR(rc);
	}
C
Cong Wang 已提交
2154 2155 2156

	vs->sock = sock;
	sk = sock->sk;
2157
	atomic_set(&vs->refcnt, 1);
P
Pravin B Shelar 已提交
2158
	vs->rcv = rcv;
2159
	vs->data = data;
2160

2161 2162 2163
	spin_lock(&vn->sock_lock);
	hlist_add_head_rcu(&vs->hlist, vs_head(net, port));
	spin_unlock(&vn->sock_lock);
2164 2165 2166 2167

	/* Mark socket as an encapsulation socket. */
	udp_sk(sk)->encap_type = 1;
	udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
C
Cong Wang 已提交
2168 2169 2170 2171 2172 2173 2174
#if IS_ENABLED(CONFIG_IPV6)
	if (ipv6)
		ipv6_stub->udpv6_encap_enable();
	else
#endif
		udp_encap_enable();

2175 2176 2177
	return vs;
}

2178 2179
struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,
				  vxlan_rcv_t *rcv, void *data,
C
Cong Wang 已提交
2180
				  bool no_share, bool ipv6)
2181 2182 2183 2184
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
	struct vxlan_sock *vs;

C
Cong Wang 已提交
2185
	vs = vxlan_socket_create(net, port, rcv, data, ipv6);
2186 2187
	if (!IS_ERR(vs))
		return vs;
2188

2189 2190 2191
	if (no_share)	/* Return error if sharing is not allowed. */
		return vs;

2192 2193
	spin_lock(&vn->sock_lock);
	vs = vxlan_find_sock(net, port);
P
Pravin B Shelar 已提交
2194 2195 2196 2197 2198 2199 2200 2201 2202
	if (vs) {
		if (vs->rcv == rcv)
			atomic_inc(&vs->refcnt);
		else
			vs = ERR_PTR(-EBUSY);
	}
	spin_unlock(&vn->sock_lock);

	if (!vs)
2203 2204
		vs = ERR_PTR(-EINVAL);

2205 2206
	return vs;
}
2207
EXPORT_SYMBOL_GPL(vxlan_sock_add);
2208

2209 2210 2211
/* Scheduled at device creation to bind to a socket */
static void vxlan_sock_work(struct work_struct *work)
{
2212 2213
	struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, sock_work);
	struct net *net = dev_net(vxlan->dev);
2214
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2215 2216
	__be16 port = vxlan->dst_port;
	struct vxlan_sock *nvs;
2217

C
Cong Wang 已提交
2218
	nvs = vxlan_sock_add(net, port, vxlan_rcv, NULL, false, vxlan->flags & VXLAN_F_IPV6);
2219
	spin_lock(&vn->sock_lock);
2220 2221 2222 2223 2224
	if (!IS_ERR(nvs))
		vxlan_vs_add_dev(nvs, vxlan);
	spin_unlock(&vn->sock_lock);

	dev_put(vxlan->dev);
2225 2226
}

S
stephen hemminger 已提交
2227 2228 2229
static int vxlan_newlink(struct net *net, struct net_device *dev,
			 struct nlattr *tb[], struct nlattr *data[])
{
2230
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
S
stephen hemminger 已提交
2231
	struct vxlan_dev *vxlan = netdev_priv(dev);
2232
	struct vxlan_rdst *dst = &vxlan->default_dst;
S
stephen hemminger 已提交
2233 2234
	__u32 vni;
	int err;
C
Cong Wang 已提交
2235
	bool use_ipv6 = false;
S
stephen hemminger 已提交
2236 2237 2238 2239 2240

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

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

C
Cong Wang 已提交
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
	if (data[IFLA_VXLAN_GROUP]) {
		dst->remote_ip.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_GROUP]);
		dst->remote_ip.sa.sa_family = AF_INET;
	} else if (data[IFLA_VXLAN_GROUP6]) {
		if (!IS_ENABLED(CONFIG_IPV6))
			return -EPFNOSUPPORT;

		nla_memcpy(&dst->remote_ip.sin6.sin6_addr, data[IFLA_VXLAN_GROUP6],
			   sizeof(struct in6_addr));
		dst->remote_ip.sa.sa_family = AF_INET6;
		use_ipv6 = true;
	}
S
stephen hemminger 已提交
2255

C
Cong Wang 已提交
2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268
	if (data[IFLA_VXLAN_LOCAL]) {
		vxlan->saddr.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_LOCAL]);
		vxlan->saddr.sa.sa_family = AF_INET;
	} else if (data[IFLA_VXLAN_LOCAL6]) {
		if (!IS_ENABLED(CONFIG_IPV6))
			return -EPFNOSUPPORT;

		/* TODO: respect scope id */
		nla_memcpy(&vxlan->saddr.sin6.sin6_addr, data[IFLA_VXLAN_LOCAL6],
			   sizeof(struct in6_addr));
		vxlan->saddr.sa.sa_family = AF_INET6;
		use_ipv6 = true;
	}
S
stephen hemminger 已提交
2269

2270
	if (data[IFLA_VXLAN_LINK] &&
2271
	    (dst->remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]))) {
2272
		struct net_device *lowerdev
2273
			 = __dev_get_by_index(net, dst->remote_ifindex);
2274 2275

		if (!lowerdev) {
2276
			pr_info("ifindex %d does not exist\n", dst->remote_ifindex);
2277 2278
			return -ENODEV;
		}
S
stephen hemminger 已提交
2279

C
Cong Wang 已提交
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290
#if IS_ENABLED(CONFIG_IPV6)
		if (use_ipv6) {
			struct inet6_dev *idev = __in6_dev_get(lowerdev);
			if (idev && idev->cnf.disable_ipv6) {
				pr_info("IPv6 is disabled via sysctl\n");
				return -EPERM;
			}
			vxlan->flags |= VXLAN_F_IPV6;
		}
#endif

2291
		if (!tb[IFLA_MTU])
C
Cong Wang 已提交
2292
			dev->mtu = lowerdev->mtu - (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
2293 2294 2295

		/* update header length based on lower device */
		dev->hard_header_len = lowerdev->hard_header_len +
C
Cong Wang 已提交
2296
				       (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
S
stephen hemminger 已提交
2297 2298 2299 2300 2301
	}

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

2302 2303 2304
	if (data[IFLA_VXLAN_TTL])
		vxlan->ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);

S
stephen hemminger 已提交
2305
	if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))
D
David Stevens 已提交
2306
		vxlan->flags |= VXLAN_F_LEARN;
S
stephen hemminger 已提交
2307 2308 2309 2310 2311 2312

	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 已提交
2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324
	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 已提交
2325 2326 2327
	if (data[IFLA_VXLAN_LIMIT])
		vxlan->addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);

2328 2329 2330 2331 2332 2333 2334
	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);
	}

2335 2336 2337
	if (data[IFLA_VXLAN_PORT])
		vxlan->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);

2338 2339 2340 2341 2342
	if (vxlan_find_vni(net, vni, vxlan->dst_port)) {
		pr_info("duplicate VNI %u\n", vni);
		return -EEXIST;
	}

Y
Yan Burman 已提交
2343 2344
	SET_ETHTOOL_OPS(dev, &vxlan_ethtool_ops);

2345 2346
	/* create an fdb entry for default destination */
	err = vxlan_fdb_create(vxlan, all_zeros_mac,
C
Cong Wang 已提交
2347
			       &vxlan->default_dst.remote_ip,
2348 2349 2350 2351
			       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);
2352
	if (err)
2353
		return err;
S
stephen hemminger 已提交
2354

2355 2356
	err = register_netdevice(dev);
	if (err) {
2357
		vxlan_fdb_delete_default(vxlan);
2358 2359 2360
		return err;
	}

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

	return 0;
S
stephen hemminger 已提交
2364 2365 2366 2367
}

static void vxlan_dellink(struct net_device *dev, struct list_head *head)
{
2368
	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
S
stephen hemminger 已提交
2369 2370
	struct vxlan_dev *vxlan = netdev_priv(dev);

2371
	spin_lock(&vn->sock_lock);
2372 2373
	if (!hlist_unhashed(&vxlan->hlist))
		hlist_del_rcu(&vxlan->hlist);
2374 2375
	spin_unlock(&vn->sock_lock);

2376
	list_del(&vxlan->next);
S
stephen hemminger 已提交
2377 2378 2379 2380 2381 2382 2383
	unregister_netdevice_queue(dev, head);
}

static size_t vxlan_get_size(const struct net_device *dev)
{

	return nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_ID */
C
Cong Wang 已提交
2384
		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */
S
stephen hemminger 已提交
2385
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LINK */
C
Cong Wang 已提交
2386
		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */
S
stephen hemminger 已提交
2387 2388 2389
		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 已提交
2390 2391 2392 2393
		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 已提交
2394 2395
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_AGEING */
		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LIMIT */
2396
		nla_total_size(sizeof(struct ifla_vxlan_port_range)) +
2397
		nla_total_size(sizeof(__be16))+ /* IFLA_VXLAN_PORT */
S
stephen hemminger 已提交
2398 2399 2400 2401 2402 2403
		0;
}

static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
{
	const struct vxlan_dev *vxlan = netdev_priv(dev);
2404
	const struct vxlan_rdst *dst = &vxlan->default_dst;
2405 2406 2407 2408
	struct ifla_vxlan_port_range ports = {
		.low =  htons(vxlan->port_min),
		.high = htons(vxlan->port_max),
	};
S
stephen hemminger 已提交
2409

2410
	if (nla_put_u32(skb, IFLA_VXLAN_ID, dst->remote_vni))
S
stephen hemminger 已提交
2411 2412
		goto nla_put_failure;

C
Cong Wang 已提交
2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425
	if (!vxlan_addr_any(&dst->remote_ip)) {
		if (dst->remote_ip.sa.sa_family == AF_INET) {
			if (nla_put_be32(skb, IFLA_VXLAN_GROUP,
					 dst->remote_ip.sin.sin_addr.s_addr))
				goto nla_put_failure;
#if IS_ENABLED(CONFIG_IPV6)
		} else {
			if (nla_put(skb, IFLA_VXLAN_GROUP6, sizeof(struct in6_addr),
				    &dst->remote_ip.sin6.sin6_addr))
				goto nla_put_failure;
#endif
		}
	}
S
stephen hemminger 已提交
2426

2427
	if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))
S
stephen hemminger 已提交
2428 2429
		goto nla_put_failure;

C
Cong Wang 已提交
2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
	if (!vxlan_addr_any(&vxlan->saddr)) {
		if (vxlan->saddr.sa.sa_family == AF_INET) {
			if (nla_put_be32(skb, IFLA_VXLAN_LOCAL,
					 vxlan->saddr.sin.sin_addr.s_addr))
				goto nla_put_failure;
#if IS_ENABLED(CONFIG_IPV6)
		} else {
			if (nla_put(skb, IFLA_VXLAN_LOCAL6, sizeof(struct in6_addr),
				    &vxlan->saddr.sin6.sin6_addr))
				goto nla_put_failure;
#endif
		}
	}
S
stephen hemminger 已提交
2443 2444 2445

	if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->ttl) ||
	    nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->tos) ||
D
David Stevens 已提交
2446 2447 2448 2449 2450 2451 2452 2453 2454
	    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 已提交
2455
	    nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->age_interval) ||
2456 2457
	    nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->addrmax) ||
	    nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->dst_port))
S
stephen hemminger 已提交
2458 2459
		goto nla_put_failure;

2460 2461 2462
	if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))
		goto nla_put_failure;

S
stephen hemminger 已提交
2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484
	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);
2485
	unsigned int h;
S
stephen hemminger 已提交
2486

2487
	INIT_LIST_HEAD(&vn->vxlan_list);
2488
	spin_lock_init(&vn->sock_lock);
S
stephen hemminger 已提交
2489

2490 2491
	for (h = 0; h < PORT_HASH_SIZE; ++h)
		INIT_HLIST_HEAD(&vn->sock_list[h]);
S
stephen hemminger 已提交
2492 2493 2494 2495 2496 2497 2498

	return 0;
}

static __net_exit void vxlan_exit_net(struct net *net)
{
	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2499
	struct vxlan_dev *vxlan;
2500
	LIST_HEAD(list);
2501 2502

	rtnl_lock();
2503
	list_for_each_entry(vxlan, &vn->vxlan_list, next)
2504 2505
		unregister_netdevice_queue(vxlan->dev, &list);
	unregister_netdevice_many(&list);
2506
	rtnl_unlock();
S
stephen hemminger 已提交
2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
}

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;

2520 2521 2522 2523
	vxlan_wq = alloc_workqueue("vxlan", 0, 0);
	if (!vxlan_wq)
		return -ENOMEM;

S
stephen hemminger 已提交
2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
	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:
2539
	destroy_workqueue(vxlan_wq);
S
stephen hemminger 已提交
2540 2541
	return rc;
}
2542
late_initcall(vxlan_init_module);
S
stephen hemminger 已提交
2543 2544 2545

static void __exit vxlan_cleanup_module(void)
{
2546
	rtnl_link_unregister(&vxlan_link_ops);
2547
	destroy_workqueue(vxlan_wq);
2548
	unregister_pernet_device(&vxlan_net_ops);
2549
	rcu_barrier();
S
stephen hemminger 已提交
2550 2551 2552 2553 2554
}
module_exit(vxlan_cleanup_module);

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