1/*
   2 * VXLAN: Virtual eXtensible Local Area Network
   3 *
   4 * Copyright (c) 2012-2013 Vyatta Inc.
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License version 2 as
   8 * published by the Free Software Foundation.
   9 */
  10
  11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13#include <linux/kernel.h>
  14#include <linux/types.h>
  15#include <linux/module.h>
  16#include <linux/errno.h>
  17#include <linux/slab.h>
  18#include <linux/skbuff.h>
  19#include <linux/rculist.h>
  20#include <linux/netdevice.h>
  21#include <linux/in.h>
  22#include <linux/ip.h>
  23#include <linux/udp.h>
  24#include <linux/igmp.h>
  25#include <linux/etherdevice.h>
  26#include <linux/if_ether.h>
  27#include <linux/if_vlan.h>
  28#include <linux/hash.h>
  29#include <linux/ethtool.h>
  30#include <net/arp.h>
  31#include <net/ndisc.h>
  32#include <net/ip.h>
  33#include <net/ip_tunnels.h>
  34#include <net/icmp.h>
  35#include <net/udp.h>
  36#include <net/udp_tunnel.h>
  37#include <net/rtnetlink.h>
  38#include <net/route.h>
  39#include <net/dsfield.h>
  40#include <net/inet_ecn.h>
  41#include <net/net_namespace.h>
  42#include <net/netns/generic.h>
  43#include <net/vxlan.h>
  44#include <net/protocol.h>
  45
  46#if IS_ENABLED(CONFIG_IPV6)
  47#include <net/ipv6.h>
  48#include <net/addrconf.h>
  49#include <net/ip6_tunnel.h>
  50#include <net/ip6_checksum.h>
  51#endif
  52#include <net/dst_metadata.h>
  53
  54#define VXLAN_VERSION	"0.1"
  55
  56#define PORT_HASH_BITS	8
  57#define PORT_HASH_SIZE  (1<<PORT_HASH_BITS)
  58#define FDB_AGE_DEFAULT 300 /* 5 min */
  59#define FDB_AGE_INTERVAL (10 * HZ)	/* rescan interval */
  60
  61/* UDP port for VXLAN traffic.
  62 * The IANA assigned port is 4789, but the Linux default is 8472
  63 * for compatibility with early adopters.
  64 */
  65static unsigned short vxlan_port __read_mostly = 8472;
  66module_param_named(udp_port, vxlan_port, ushort, 0444);
  67MODULE_PARM_DESC(udp_port, "Destination UDP port");
  68
  69static bool log_ecn_error = true;
  70module_param(log_ecn_error, bool, 0644);
  71MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
  72
  73static int vxlan_net_id;
  74static struct rtnl_link_ops vxlan_link_ops;
  75
  76static const u8 all_zeros_mac[ETH_ALEN + 2];
  77
  78static int vxlan_sock_add(struct vxlan_dev *vxlan);
  79
  80/* per-network namespace private data for this module */
  81struct vxlan_net {
  82	struct list_head  vxlan_list;
  83	struct hlist_head sock_list[PORT_HASH_SIZE];
  84	spinlock_t	  sock_lock;
  85};
  86
  87/* Forwarding table entry */
  88struct vxlan_fdb {
  89	struct hlist_node hlist;	/* linked list of entries */
  90	struct rcu_head	  rcu;
  91	unsigned long	  updated;	/* jiffies */
  92	unsigned long	  used;
  93	struct list_head  remotes;
  94	u8		  eth_addr[ETH_ALEN];
  95	u16		  state;	/* see ndm_state */
  96	u8		  flags;	/* see ndm_flags */
  97};
  98
  99/* salt for hash table */
 100static u32 vxlan_salt __read_mostly;
 101static struct workqueue_struct *vxlan_wq;
 102
 103static inline bool vxlan_collect_metadata(struct vxlan_sock *vs)
 104{
 105	return vs->flags & VXLAN_F_COLLECT_METADATA ||
 106	       ip_tunnel_collect_metadata();
 107}
 108
 109#if IS_ENABLED(CONFIG_IPV6)
 110static inline
 111bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
 112{
 113	if (a->sa.sa_family != b->sa.sa_family)
 114		return false;
 115	if (a->sa.sa_family == AF_INET6)
 116		return ipv6_addr_equal(&a->sin6.sin6_addr, &b->sin6.sin6_addr);
 117	else
 118		return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
 119}
 120
 121static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
 122{
 123	if (ipa->sa.sa_family == AF_INET6)
 124		return ipv6_addr_any(&ipa->sin6.sin6_addr);
 125	else
 126		return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
 127}
 128
 129static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
 130{
 131	if (ipa->sa.sa_family == AF_INET6)
 132		return ipv6_addr_is_multicast(&ipa->sin6.sin6_addr);
 133	else
 134		return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
 135}
 136
 137static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
 138{
 139	if (nla_len(nla) >= sizeof(struct in6_addr)) {
 140		ip->sin6.sin6_addr = nla_get_in6_addr(nla);
 141		ip->sa.sa_family = AF_INET6;
 142		return 0;
 143	} else if (nla_len(nla) >= sizeof(__be32)) {
 144		ip->sin.sin_addr.s_addr = nla_get_in_addr(nla);
 145		ip->sa.sa_family = AF_INET;
 146		return 0;
 147	} else {
 148		return -EAFNOSUPPORT;
 149	}
 150}
 151
 152static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
 153			      const union vxlan_addr *ip)
 154{
 155	if (ip->sa.sa_family == AF_INET6)
 156		return nla_put_in6_addr(skb, attr, &ip->sin6.sin6_addr);
 157	else
 158		return nla_put_in_addr(skb, attr, ip->sin.sin_addr.s_addr);
 159}
 160
 161#else /* !CONFIG_IPV6 */
 162
 163static inline
 164bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
 165{
 166	return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
 167}
 168
 169static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
 170{
 171	return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
 172}
 173
 174static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
 175{
 176	return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
 177}
 178
 179static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
 180{
 181	if (nla_len(nla) >= sizeof(struct in6_addr)) {
 182		return -EAFNOSUPPORT;
 183	} else if (nla_len(nla) >= sizeof(__be32)) {
 184		ip->sin.sin_addr.s_addr = nla_get_in_addr(nla);
 185		ip->sa.sa_family = AF_INET;
 186		return 0;
 187	} else {
 188		return -EAFNOSUPPORT;
 189	}
 190}
 191
 192static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
 193			      const union vxlan_addr *ip)
 194{
 195	return nla_put_in_addr(skb, attr, ip->sin.sin_addr.s_addr);
 196}
 197#endif
 198
 199/* Virtual Network hash table head */
 200static inline struct hlist_head *vni_head(struct vxlan_sock *vs, __be32 vni)
 201{
 202	return &vs->vni_list[hash_32((__force u32)vni, VNI_HASH_BITS)];
 203}
 204
 205/* Socket hash table head */
 206static inline struct hlist_head *vs_head(struct net *net, __be16 port)
 207{
 208	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 209
 210	return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
 211}
 212
 213/* First remote destination for a forwarding entry.
 214 * Guaranteed to be non-NULL because remotes are never deleted.
 215 */
 216static inline struct vxlan_rdst *first_remote_rcu(struct vxlan_fdb *fdb)
 217{
 218	return list_entry_rcu(fdb->remotes.next, struct vxlan_rdst, list);
 219}
 220
 221static inline struct vxlan_rdst *first_remote_rtnl(struct vxlan_fdb *fdb)
 222{
 223	return list_first_entry(&fdb->remotes, struct vxlan_rdst, list);
 224}
 225
 226/* Find VXLAN socket based on network namespace, address family and UDP port
 227 * and enabled unshareable flags.
 228 */
 229static struct vxlan_sock *vxlan_find_sock(struct net *net, sa_family_t family,
 230					  __be16 port, u32 flags)
 231{
 232	struct vxlan_sock *vs;
 233
 234	flags &= VXLAN_F_RCV_FLAGS;
 235
 236	hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {
 237		if (inet_sk(vs->sock->sk)->inet_sport == port &&
 238		    vxlan_get_sk_family(vs) == family &&
 239		    vs->flags == flags)
 240			return vs;
 241	}
 242	return NULL;
 243}
 244
 245static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs, __be32 vni)
 246{
 247	struct vxlan_dev *vxlan;
 248
 249	/* For flow based devices, map all packets to VNI 0 */
 250	if (vs->flags & VXLAN_F_COLLECT_METADATA)
 251		vni = 0;
 252
 253	hlist_for_each_entry_rcu(vxlan, vni_head(vs, vni), hlist) {
 254		if (vxlan->default_dst.remote_vni == vni)
 255			return vxlan;
 256	}
 257
 258	return NULL;
 259}
 260
 261/* Look up VNI in a per net namespace table */
 262static struct vxlan_dev *vxlan_find_vni(struct net *net, __be32 vni,
 263					sa_family_t family, __be16 port,
 264					u32 flags)
 265{
 266	struct vxlan_sock *vs;
 267
 268	vs = vxlan_find_sock(net, family, port, flags);
 269	if (!vs)
 270		return NULL;
 271
 272	return vxlan_vs_find_vni(vs, vni);
 273}
 274
 275/* Fill in neighbour message in skbuff. */
 276static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,
 277			  const struct vxlan_fdb *fdb,
 278			  u32 portid, u32 seq, int type, unsigned int flags,
 279			  const struct vxlan_rdst *rdst)
 280{
 281	unsigned long now = jiffies;
 282	struct nda_cacheinfo ci;
 283	struct nlmsghdr *nlh;
 284	struct ndmsg *ndm;
 285	bool send_ip, send_eth;
 286
 287	nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
 288	if (nlh == NULL)
 289		return -EMSGSIZE;
 290
 291	ndm = nlmsg_data(nlh);
 292	memset(ndm, 0, sizeof(*ndm));
 293
 294	send_eth = send_ip = true;
 295
 296	if (type == RTM_GETNEIGH) {
 297		ndm->ndm_family	= AF_INET;
 298		send_ip = !vxlan_addr_any(&rdst->remote_ip);
 299		send_eth = !is_zero_ether_addr(fdb->eth_addr);
 300	} else
 301		ndm->ndm_family	= AF_BRIDGE;
 302	ndm->ndm_state = fdb->state;
 303	ndm->ndm_ifindex = vxlan->dev->ifindex;
 304	ndm->ndm_flags = fdb->flags;
 305	ndm->ndm_type = RTN_UNICAST;
 306
 307	if (!net_eq(dev_net(vxlan->dev), vxlan->net) &&
 308	    nla_put_s32(skb, NDA_LINK_NETNSID,
 309			peernet2id_alloc(dev_net(vxlan->dev), vxlan->net)))
 310		goto nla_put_failure;
 311
 312	if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))
 313		goto nla_put_failure;
 314
 315	if (send_ip && vxlan_nla_put_addr(skb, NDA_DST, &rdst->remote_ip))
 316		goto nla_put_failure;
 317
 318	if (rdst->remote_port && rdst->remote_port != vxlan->cfg.dst_port &&
 319	    nla_put_be16(skb, NDA_PORT, rdst->remote_port))
 320		goto nla_put_failure;
 321	if (rdst->remote_vni != vxlan->default_dst.remote_vni &&
 322	    nla_put_u32(skb, NDA_VNI, be32_to_cpu(rdst->remote_vni)))
 323		goto nla_put_failure;
 324	if (rdst->remote_ifindex &&
 325	    nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
 326		goto nla_put_failure;
 327
 328	ci.ndm_used	 = jiffies_to_clock_t(now - fdb->used);
 329	ci.ndm_confirmed = 0;
 330	ci.ndm_updated	 = jiffies_to_clock_t(now - fdb->updated);
 331	ci.ndm_refcnt	 = 0;
 332
 333	if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
 334		goto nla_put_failure;
 335
 336	nlmsg_end(skb, nlh);
 337	return 0;
 338
 339nla_put_failure:
 340	nlmsg_cancel(skb, nlh);
 341	return -EMSGSIZE;
 342}
 343
 344static inline size_t vxlan_nlmsg_size(void)
 345{
 346	return NLMSG_ALIGN(sizeof(struct ndmsg))
 347		+ nla_total_size(ETH_ALEN) /* NDA_LLADDR */
 348		+ nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */
 349		+ nla_total_size(sizeof(__be16)) /* NDA_PORT */
 350		+ nla_total_size(sizeof(__be32)) /* NDA_VNI */
 351		+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
 352		+ nla_total_size(sizeof(__s32)) /* NDA_LINK_NETNSID */
 353		+ nla_total_size(sizeof(struct nda_cacheinfo));
 354}
 355
 356static void vxlan_fdb_notify(struct vxlan_dev *vxlan, struct vxlan_fdb *fdb,
 357			     struct vxlan_rdst *rd, int type)
 358{
 359	struct net *net = dev_net(vxlan->dev);
 360	struct sk_buff *skb;
 361	int err = -ENOBUFS;
 362
 363	skb = nlmsg_new(vxlan_nlmsg_size(), GFP_ATOMIC);
 364	if (skb == NULL)
 365		goto errout;
 366
 367	err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0, rd);
 368	if (err < 0) {
 369		/* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */
 370		WARN_ON(err == -EMSGSIZE);
 371		kfree_skb(skb);
 372		goto errout;
 373	}
 374
 375	rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
 376	return;
 377errout:
 378	if (err < 0)
 379		rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
 380}
 381
 382static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)
 383{
 384	struct vxlan_dev *vxlan = netdev_priv(dev);
 385	struct vxlan_fdb f = {
 386		.state = NUD_STALE,
 387	};
 388	struct vxlan_rdst remote = {
 389		.remote_ip = *ipa, /* goes to NDA_DST */
 390		.remote_vni = cpu_to_be32(VXLAN_N_VID),
 391	};
 392
 393	vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH);
 394}
 395
 396static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])
 397{
 398	struct vxlan_fdb f = {
 399		.state = NUD_STALE,
 400	};
 401	struct vxlan_rdst remote = { };
 402
 403	memcpy(f.eth_addr, eth_addr, ETH_ALEN);
 404
 405	vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH);
 406}
 407
 408/* Hash Ethernet address */
 409static u32 eth_hash(const unsigned char *addr)
 410{
 411	u64 value = get_unaligned((u64 *)addr);
 412
 413	/* only want 6 bytes */
 414#ifdef __BIG_ENDIAN
 415	value >>= 16;
 416#else
 417	value <<= 16;
 418#endif
 419	return hash_64(value, FDB_HASH_BITS);
 420}
 421
 422/* Hash chain to use given mac address */
 423static inline struct hlist_head *vxlan_fdb_head(struct vxlan_dev *vxlan,
 424						const u8 *mac)
 425{
 426	return &vxlan->fdb_head[eth_hash(mac)];
 427}
 428
 429/* Look up Ethernet address in forwarding table */
 430static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,
 431					const u8 *mac)
 432{
 433	struct hlist_head *head = vxlan_fdb_head(vxlan, mac);
 434	struct vxlan_fdb *f;
 435
 436	hlist_for_each_entry_rcu(f, head, hlist) {
 437		if (ether_addr_equal(mac, f->eth_addr))
 438			return f;
 439	}
 440
 441	return NULL;
 442}
 443
 444static struct vxlan_fdb *vxlan_find_mac(struct vxlan_dev *vxlan,
 445					const u8 *mac)
 446{
 447	struct vxlan_fdb *f;
 448
 449	f = __vxlan_find_mac(vxlan, mac);
 450	if (f)
 451		f->used = jiffies;
 452
 453	return f;
 454}
 455
 456/* caller should hold vxlan->hash_lock */
 457static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,
 458					      union vxlan_addr *ip, __be16 port,
 459					      __be32 vni, __u32 ifindex)
 460{
 461	struct vxlan_rdst *rd;
 462
 463	list_for_each_entry(rd, &f->remotes, list) {
 464		if (vxlan_addr_equal(&rd->remote_ip, ip) &&
 465		    rd->remote_port == port &&
 466		    rd->remote_vni == vni &&
 467		    rd->remote_ifindex == ifindex)
 468			return rd;
 469	}
 470
 471	return NULL;
 472}
 473
 474/* Replace destination of unicast mac */
 475static int vxlan_fdb_replace(struct vxlan_fdb *f,
 476			     union vxlan_addr *ip, __be16 port, __be32 vni,
 477			     __u32 ifindex)
 478{
 479	struct vxlan_rdst *rd;
 480
 481	rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
 482	if (rd)
 483		return 0;
 484
 485	rd = list_first_entry_or_null(&f->remotes, struct vxlan_rdst, list);
 486	if (!rd)
 487		return 0;
 488
 489	dst_cache_reset(&rd->dst_cache);
 490	rd->remote_ip = *ip;
 491	rd->remote_port = port;
 492	rd->remote_vni = vni;
 493	rd->remote_ifindex = ifindex;
 494	return 1;
 495}
 496
 497/* Add/update destinations for multicast */
 498static int vxlan_fdb_append(struct vxlan_fdb *f,
 499			    union vxlan_addr *ip, __be16 port, __be32 vni,
 500			    __u32 ifindex, struct vxlan_rdst **rdp)
 501{
 502	struct vxlan_rdst *rd;
 503
 504	rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
 505	if (rd)
 506		return 0;
 507
 508	rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
 509	if (rd == NULL)
 510		return -ENOBUFS;
 511
 512	if (dst_cache_init(&rd->dst_cache, GFP_ATOMIC)) {
 513		kfree(rd);
 514		return -ENOBUFS;
 515	}
 516
 517	rd->remote_ip = *ip;
 518	rd->remote_port = port;
 519	rd->remote_vni = vni;
 520	rd->remote_ifindex = ifindex;
 521
 522	list_add_tail_rcu(&rd->list, &f->remotes);
 523
 524	*rdp = rd;
 525	return 1;
 526}
 527
 528static struct vxlanhdr *vxlan_gro_remcsum(struct sk_buff *skb,
 529					  unsigned int off,
 530					  struct vxlanhdr *vh, size_t hdrlen,
 531					  __be32 vni_field,
 532					  struct gro_remcsum *grc,
 533					  bool nopartial)
 534{
 535	size_t start, offset;
 536
 537	if (skb->remcsum_offload)
 538		return vh;
 539
 540	if (!NAPI_GRO_CB(skb)->csum_valid)
 541		return NULL;
 542
 543	start = vxlan_rco_start(vni_field);
 544	offset = start + vxlan_rco_offset(vni_field);
 545
 546	vh = skb_gro_remcsum_process(skb, (void *)vh, off, hdrlen,
 547				     start, offset, grc, nopartial);
 548
 549	skb->remcsum_offload = 1;
 550
 551	return vh;
 552}
 553
 554static struct sk_buff **vxlan_gro_receive(struct sk_buff **head,
 555					  struct sk_buff *skb,
 556					  struct udp_offload *uoff)
 557{
 558	struct sk_buff *p, **pp = NULL;
 559	struct vxlanhdr *vh, *vh2;
 560	unsigned int hlen, off_vx;
 561	int flush = 1;
 562	struct vxlan_sock *vs = container_of(uoff, struct vxlan_sock,
 563					     udp_offloads);
 564	__be32 flags;
 565	struct gro_remcsum grc;
 566
 567	skb_gro_remcsum_init(&grc);
 568
 569	off_vx = skb_gro_offset(skb);
 570	hlen = off_vx + sizeof(*vh);
 571	vh   = skb_gro_header_fast(skb, off_vx);
 572	if (skb_gro_header_hard(skb, hlen)) {
 573		vh = skb_gro_header_slow(skb, hlen, off_vx);
 574		if (unlikely(!vh))
 575			goto out;
 576	}
 577
 578	skb_gro_postpull_rcsum(skb, vh, sizeof(struct vxlanhdr));
 579
 580	flags = vh->vx_flags;
 581
 582	if ((flags & VXLAN_HF_RCO) && (vs->flags & VXLAN_F_REMCSUM_RX)) {
 583		vh = vxlan_gro_remcsum(skb, off_vx, vh, sizeof(struct vxlanhdr),
 584				       vh->vx_vni, &grc,
 585				       !!(vs->flags &
 586					  VXLAN_F_REMCSUM_NOPARTIAL));
 587
 588		if (!vh)
 589			goto out;
 590	}
 591
 592	skb_gro_pull(skb, sizeof(struct vxlanhdr)); /* pull vxlan header */
 593
 594	for (p = *head; p; p = p->next) {
 595		if (!NAPI_GRO_CB(p)->same_flow)
 596			continue;
 597
 598		vh2 = (struct vxlanhdr *)(p->data + off_vx);
 599		if (vh->vx_flags != vh2->vx_flags ||
 600		    vh->vx_vni != vh2->vx_vni) {
 601			NAPI_GRO_CB(p)->same_flow = 0;
 602			continue;
 603		}
 604	}
 605
 606	pp = eth_gro_receive(head, skb);
 607	flush = 0;
 608
 609out:
 610	skb_gro_remcsum_cleanup(skb, &grc);
 611	NAPI_GRO_CB(skb)->flush |= flush;
 612
 613	return pp;
 614}
 615
 616static int vxlan_gro_complete(struct sk_buff *skb, int nhoff,
 617			      struct udp_offload *uoff)
 618{
 619	/* Sets 'skb->inner_mac_header' since we are always called with
 620	 * 'skb->encapsulation' set.
 621	 */
 622	return eth_gro_complete(skb, nhoff + sizeof(struct vxlanhdr));
 623}
 624
 625/* Notify netdevs that UDP port started listening */
 626static void vxlan_notify_add_rx_port(struct vxlan_sock *vs)
 627{
 628	struct net_device *dev;
 629	struct sock *sk = vs->sock->sk;
 630	struct net *net = sock_net(sk);
 631	sa_family_t sa_family = vxlan_get_sk_family(vs);
 632	__be16 port = inet_sk(sk)->inet_sport;
 633	int err;
 634
 635	if (sa_family == AF_INET) {
 636		err = udp_add_offload(net, &vs->udp_offloads);
 637		if (err)
 638			pr_warn("vxlan: udp_add_offload failed with status %d\n", err);
 639	}
 640
 641	rcu_read_lock();
 642	for_each_netdev_rcu(net, dev) {
 643		if (dev->netdev_ops->ndo_add_vxlan_port)
 644			dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,
 645							    port);
 646	}
 647	rcu_read_unlock();
 648}
 649
 650/* Notify netdevs that UDP port is no more listening */
 651static void vxlan_notify_del_rx_port(struct vxlan_sock *vs)
 652{
 653	struct net_device *dev;
 654	struct sock *sk = vs->sock->sk;
 655	struct net *net = sock_net(sk);
 656	sa_family_t sa_family = vxlan_get_sk_family(vs);
 657	__be16 port = inet_sk(sk)->inet_sport;
 658
 659	rcu_read_lock();
 660	for_each_netdev_rcu(net, dev) {
 661		if (dev->netdev_ops->ndo_del_vxlan_port)
 662			dev->netdev_ops->ndo_del_vxlan_port(dev, sa_family,
 663							    port);
 664	}
 665	rcu_read_unlock();
 666
 667	if (sa_family == AF_INET)
 668		udp_del_offload(&vs->udp_offloads);
 669}
 670
 671/* Add new entry to forwarding table -- assumes lock held */
 672static int vxlan_fdb_create(struct vxlan_dev *vxlan,
 673			    const u8 *mac, union vxlan_addr *ip,
 674			    __u16 state, __u16 flags,
 675			    __be16 port, __be32 vni, __u32 ifindex,
 676			    __u8 ndm_flags)
 677{
 678	struct vxlan_rdst *rd = NULL;
 679	struct vxlan_fdb *f;
 680	int notify = 0;
 681
 682	f = __vxlan_find_mac(vxlan, mac);
 683	if (f) {
 684		if (flags & NLM_F_EXCL) {
 685			netdev_dbg(vxlan->dev,
 686				   "lost race to create %pM\n", mac);
 687			return -EEXIST;
 688		}
 689		if (f->state != state) {
 690			f->state = state;
 691			f->updated = jiffies;
 692			notify = 1;
 693		}
 694		if (f->flags != ndm_flags) {
 695			f->flags = ndm_flags;
 696			f->updated = jiffies;
 697			notify = 1;
 698		}
 699		if ((flags & NLM_F_REPLACE)) {
 700			/* Only change unicasts */
 701			if (!(is_multicast_ether_addr(f->eth_addr) ||
 702			     is_zero_ether_addr(f->eth_addr))) {
 703				notify |= vxlan_fdb_replace(f, ip, port, vni,
 704							   ifindex);
 705			} else
 706				return -EOPNOTSUPP;
 707		}
 708		if ((flags & NLM_F_APPEND) &&
 709		    (is_multicast_ether_addr(f->eth_addr) ||
 710		     is_zero_ether_addr(f->eth_addr))) {
 711			int rc = vxlan_fdb_append(f, ip, port, vni, ifindex,
 712						  &rd);
 713
 714			if (rc < 0)
 715				return rc;
 716			notify |= rc;
 717		}
 718	} else {
 719		if (!(flags & NLM_F_CREATE))
 720			return -ENOENT;
 721
 722		if (vxlan->cfg.addrmax &&
 723		    vxlan->addrcnt >= vxlan->cfg.addrmax)
 724			return -ENOSPC;
 725
 726		/* Disallow replace to add a multicast entry */
 727		if ((flags & NLM_F_REPLACE) &&
 728		    (is_multicast_ether_addr(mac) || is_zero_ether_addr(mac)))
 729			return -EOPNOTSUPP;
 730
 731		netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);
 732		f = kmalloc(sizeof(*f), GFP_ATOMIC);
 733		if (!f)
 734			return -ENOMEM;
 735
 736		notify = 1;
 737		f->state = state;
 738		f->flags = ndm_flags;
 739		f->updated = f->used = jiffies;
 740		INIT_LIST_HEAD(&f->remotes);
 741		memcpy(f->eth_addr, mac, ETH_ALEN);
 742
 743		vxlan_fdb_append(f, ip, port, vni, ifindex, &rd);
 744
 745		++vxlan->addrcnt;
 746		hlist_add_head_rcu(&f->hlist,
 747				   vxlan_fdb_head(vxlan, mac));
 748	}
 749
 750	if (notify) {
 751		if (rd == NULL)
 752			rd = first_remote_rtnl(f);
 753		vxlan_fdb_notify(vxlan, f, rd, RTM_NEWNEIGH);
 754	}
 755
 756	return 0;
 757}
 758
 759static void vxlan_fdb_free(struct rcu_head *head)
 760{
 761	struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);
 762	struct vxlan_rdst *rd, *nd;
 763
 764	list_for_each_entry_safe(rd, nd, &f->remotes, list) {
 765		dst_cache_destroy(&rd->dst_cache);
 766		kfree(rd);
 767	}
 768	kfree(f);
 769}
 770
 771static void vxlan_fdb_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f)
 772{
 773	netdev_dbg(vxlan->dev,
 774		    "delete %pM\n", f->eth_addr);
 775
 776	--vxlan->addrcnt;
 777	vxlan_fdb_notify(vxlan, f, first_remote_rtnl(f), RTM_DELNEIGH);
 778
 779	hlist_del_rcu(&f->hlist);
 780	call_rcu(&f->rcu, vxlan_fdb_free);
 781}
 782
 783static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,
 784			   union vxlan_addr *ip, __be16 *port, __be32 *vni,
 785			   u32 *ifindex)
 786{
 787	struct net *net = dev_net(vxlan->dev);
 788	int err;
 789
 790	if (tb[NDA_DST]) {
 791		err = vxlan_nla_get_addr(ip, tb[NDA_DST]);
 792		if (err)
 793			return err;
 794	} else {
 795		union vxlan_addr *remote = &vxlan->default_dst.remote_ip;
 796		if (remote->sa.sa_family == AF_INET) {
 797			ip->sin.sin_addr.s_addr = htonl(INADDR_ANY);
 798			ip->sa.sa_family = AF_INET;
 799#if IS_ENABLED(CONFIG_IPV6)
 800		} else {
 801			ip->sin6.sin6_addr = in6addr_any;
 802			ip->sa.sa_family = AF_INET6;
 803#endif
 804		}
 805	}
 806
 807	if (tb[NDA_PORT]) {
 808		if (nla_len(tb[NDA_PORT]) != sizeof(__be16))
 809			return -EINVAL;
 810		*port = nla_get_be16(tb[NDA_PORT]);
 811	} else {
 812		*port = vxlan->cfg.dst_port;
 813	}
 814
 815	if (tb[NDA_VNI]) {
 816		if (nla_len(tb[NDA_VNI]) != sizeof(u32))
 817			return -EINVAL;
 818		*vni = cpu_to_be32(nla_get_u32(tb[NDA_VNI]));
 819	} else {
 820		*vni = vxlan->default_dst.remote_vni;
 821	}
 822
 823	if (tb[NDA_IFINDEX]) {
 824		struct net_device *tdev;
 825
 826		if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
 827			return -EINVAL;
 828		*ifindex = nla_get_u32(tb[NDA_IFINDEX]);
 829		tdev = __dev_get_by_index(net, *ifindex);
 830		if (!tdev)
 831			return -EADDRNOTAVAIL;
 832	} else {
 833		*ifindex = 0;
 834	}
 835
 836	return 0;
 837}
 838
 839/* Add static entry (via netlink) */
 840static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
 841			 struct net_device *dev,
 842			 const unsigned char *addr, u16 vid, u16 flags)
 843{
 844	struct vxlan_dev *vxlan = netdev_priv(dev);
 845	/* struct net *net = dev_net(vxlan->dev); */
 846	union vxlan_addr ip;
 847	__be16 port;
 848	__be32 vni;
 849	u32 ifindex;
 850	int err;
 851
 852	if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_REACHABLE))) {
 853		pr_info("RTM_NEWNEIGH with invalid state %#x\n",
 854			ndm->ndm_state);
 855		return -EINVAL;
 856	}
 857
 858	if (tb[NDA_DST] == NULL)
 859		return -EINVAL;
 860
 861	err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);
 862	if (err)
 863		return err;
 864
 865	if (vxlan->default_dst.remote_ip.sa.sa_family != ip.sa.sa_family)
 866		return -EAFNOSUPPORT;
 867
 868	spin_lock_bh(&vxlan->hash_lock);
 869	err = vxlan_fdb_create(vxlan, addr, &ip, ndm->ndm_state, flags,
 870			       port, vni, ifindex, ndm->ndm_flags);
 871	spin_unlock_bh(&vxlan->hash_lock);
 872
 873	return err;
 874}
 875
 876/* Delete entry (via netlink) */
 877static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
 878			    struct net_device *dev,
 879			    const unsigned char *addr, u16 vid)
 880{
 881	struct vxlan_dev *vxlan = netdev_priv(dev);
 882	struct vxlan_fdb *f;
 883	struct vxlan_rdst *rd = NULL;
 884	union vxlan_addr ip;
 885	__be16 port;
 886	__be32 vni;
 887	u32 ifindex;
 888	int err;
 889
 890	err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);
 891	if (err)
 892		return err;
 893
 894	err = -ENOENT;
 895
 896	spin_lock_bh(&vxlan->hash_lock);
 897	f = vxlan_find_mac(vxlan, addr);
 898	if (!f)
 899		goto out;
 900
 901	if (!vxlan_addr_any(&ip)) {
 902		rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);
 903		if (!rd)
 904			goto out;
 905	}
 906
 907	err = 0;
 908
 909	/* remove a destination if it's not the only one on the list,
 910	 * otherwise destroy the fdb entry
 911	 */
 912	if (rd && !list_is_singular(&f->remotes)) {
 913		list_del_rcu(&rd->list);
 914		vxlan_fdb_notify(vxlan, f, rd, RTM_DELNEIGH);
 915		kfree_rcu(rd, rcu);
 916		goto out;
 917	}
 918
 919	vxlan_fdb_destroy(vxlan, f);
 920
 921out:
 922	spin_unlock_bh(&vxlan->hash_lock);
 923
 924	return err;
 925}
 926
 927/* Dump forwarding table */
 928static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
 929			  struct net_device *dev,
 930			  struct net_device *filter_dev, int idx)
 931{
 932	struct vxlan_dev *vxlan = netdev_priv(dev);
 933	unsigned int h;
 934
 935	for (h = 0; h < FDB_HASH_SIZE; ++h) {
 936		struct vxlan_fdb *f;
 937		int err;
 938
 939		hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
 940			struct vxlan_rdst *rd;
 941
 942			list_for_each_entry_rcu(rd, &f->remotes, list) {
 943				if (idx < cb->args[0])
 944					goto skip;
 945
 946				err = vxlan_fdb_info(skb, vxlan, f,
 947						     NETLINK_CB(cb->skb).portid,
 948						     cb->nlh->nlmsg_seq,
 949						     RTM_NEWNEIGH,
 950						     NLM_F_MULTI, rd);
 951				if (err < 0) {
 952					cb->args[1] = err;
 953					goto out;
 954				}
 955skip:
 956				++idx;
 957			}
 958		}
 959	}
 960out:
 961	return idx;
 962}
 963
 964/* Watch incoming packets to learn mapping between Ethernet address
 965 * and Tunnel endpoint.
 966 * Return true if packet is bogus and should be dropped.
 967 */
 968static bool vxlan_snoop(struct net_device *dev,
 969			union vxlan_addr *src_ip, const u8 *src_mac)
 970{
 971	struct vxlan_dev *vxlan = netdev_priv(dev);
 972	struct vxlan_fdb *f;
 973
 974	f = vxlan_find_mac(vxlan, src_mac);
 975	if (likely(f)) {
 976		struct vxlan_rdst *rdst = first_remote_rcu(f);
 977
 978		if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip)))
 979			return false;
 980
 981		/* Don't migrate static entries, drop packets */
 982		if (f->state & NUD_NOARP)
 983			return true;
 984
 985		if (net_ratelimit())
 986			netdev_info(dev,
 987				    "%pM migrated from %pIS to %pIS\n",
 988				    src_mac, &rdst->remote_ip.sa, &src_ip->sa);
 989
 990		rdst->remote_ip = *src_ip;
 991		f->updated = jiffies;
 992		vxlan_fdb_notify(vxlan, f, rdst, RTM_NEWNEIGH);
 993	} else {
 994		/* learned new entry */
 995		spin_lock(&vxlan->hash_lock);
 996
 997		/* close off race between vxlan_flush and incoming packets */
 998		if (netif_running(dev))
 999			vxlan_fdb_create(vxlan, src_mac, src_ip,
1000					 NUD_REACHABLE,
1001					 NLM_F_EXCL|NLM_F_CREATE,
1002					 vxlan->cfg.dst_port,
1003					 vxlan->default_dst.remote_vni,
1004					 0, NTF_SELF);
1005		spin_unlock(&vxlan->hash_lock);
1006	}
1007
1008	return false;
1009}
1010
1011/* See if multicast group is already in use by other ID */
1012static bool vxlan_group_used(struct vxlan_net *vn, struct vxlan_dev *dev)
1013{
1014	struct vxlan_dev *vxlan;
1015	unsigned short family = dev->default_dst.remote_ip.sa.sa_family;
1016
1017	/* The vxlan_sock is only used by dev, leaving group has
1018	 * no effect on other vxlan devices.
1019	 */
1020	if (family == AF_INET && dev->vn4_sock &&
1021	    atomic_read(&dev->vn4_sock->refcnt) == 1)
1022		return false;
1023#if IS_ENABLED(CONFIG_IPV6)
1024	if (family == AF_INET6 && dev->vn6_sock &&
1025	    atomic_read(&dev->vn6_sock->refcnt) == 1)
1026		return false;
1027#endif
1028
1029	list_for_each_entry(vxlan, &vn->vxlan_list, next) {
1030		if (!netif_running(vxlan->dev) || vxlan == dev)
1031			continue;
1032
1033		if (family == AF_INET && vxlan->vn4_sock != dev->vn4_sock)
1034			continue;
1035#if IS_ENABLED(CONFIG_IPV6)
1036		if (family == AF_INET6 && vxlan->vn6_sock != dev->vn6_sock)
1037			continue;
1038#endif
1039
1040		if (!vxlan_addr_equal(&vxlan->default_dst.remote_ip,
1041				      &dev->default_dst.remote_ip))
1042			continue;
1043
1044		if (vxlan->default_dst.remote_ifindex !=
1045		    dev->default_dst.remote_ifindex)
1046			continue;
1047
1048		return true;
1049	}
1050
1051	return false;
1052}
1053
1054static void __vxlan_sock_release(struct vxlan_sock *vs)
1055{
1056	struct vxlan_net *vn;
1057
1058	if (!vs)
1059		return;
1060	if (!atomic_dec_and_test(&vs->refcnt))
1061		return;
1062
1063	vn = net_generic(sock_net(vs->sock->sk), vxlan_net_id);
1064	spin_lock(&vn->sock_lock);
1065	hlist_del_rcu(&vs->hlist);
1066	vxlan_notify_del_rx_port(vs);
1067	spin_unlock(&vn->sock_lock);
1068
1069	queue_work(vxlan_wq, &vs->del_work);
1070}
1071
1072static void vxlan_sock_release(struct vxlan_dev *vxlan)
1073{
1074	__vxlan_sock_release(vxlan->vn4_sock);
1075#if IS_ENABLED(CONFIG_IPV6)
1076	__vxlan_sock_release(vxlan->vn6_sock);
1077#endif
1078}
1079
1080/* Update multicast group membership when first VNI on
1081 * multicast address is brought up
1082 */
1083static int vxlan_igmp_join(struct vxlan_dev *vxlan)
1084{
1085	struct sock *sk;
1086	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
1087	int ifindex = vxlan->default_dst.remote_ifindex;
1088	int ret = -EINVAL;
1089
1090	if (ip->sa.sa_family == AF_INET) {
1091		struct ip_mreqn mreq = {
1092			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
1093			.imr_ifindex		= ifindex,
1094		};
1095
1096		sk = vxlan->vn4_sock->sock->sk;
1097		lock_sock(sk);
1098		ret = ip_mc_join_group(sk, &mreq);
1099		release_sock(sk);
1100#if IS_ENABLED(CONFIG_IPV6)
1101	} else {
1102		sk = vxlan->vn6_sock->sock->sk;
1103		lock_sock(sk);
1104		ret = ipv6_stub->ipv6_sock_mc_join(sk, ifindex,
1105						   &ip->sin6.sin6_addr);
1106		release_sock(sk);
1107#endif
1108	}
1109
1110	return ret;
1111}
1112
1113/* Inverse of vxlan_igmp_join when last VNI is brought down */
1114static int vxlan_igmp_leave(struct vxlan_dev *vxlan)
1115{
1116	struct sock *sk;
1117	union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
1118	int ifindex = vxlan->default_dst.remote_ifindex;
1119	int ret = -EINVAL;
1120
1121	if (ip->sa.sa_family == AF_INET) {
1122		struct ip_mreqn mreq = {
1123			.imr_multiaddr.s_addr	= ip->sin.sin_addr.s_addr,
1124			.imr_ifindex		= ifindex,
1125		};
1126
1127		sk = vxlan->vn4_sock->sock->sk;
1128		lock_sock(sk);
1129		ret = ip_mc_leave_group(sk, &mreq);
1130		release_sock(sk);
1131#if IS_ENABLED(CONFIG_IPV6)
1132	} else {
1133		sk = vxlan->vn6_sock->sock->sk;
1134		lock_sock(sk);
1135		ret = ipv6_stub->ipv6_sock_mc_drop(sk, ifindex,
1136						   &ip->sin6.sin6_addr);
1137		release_sock(sk);
1138#endif
1139	}
1140
1141	return ret;
1142}
1143
1144static bool vxlan_remcsum(struct vxlanhdr *unparsed,
1145			  struct sk_buff *skb, u32 vxflags)
1146{
1147	size_t start, offset;
1148
1149	if (!(unparsed->vx_flags & VXLAN_HF_RCO) || skb->remcsum_offload)
1150		goto out;
1151
1152	start = vxlan_rco_start(unparsed->vx_vni);
1153	offset = start + vxlan_rco_offset(unparsed->vx_vni);
1154
1155	if (!pskb_may_pull(skb, offset + sizeof(u16)))
1156		return false;
1157
1158	skb_remcsum_process(skb, (void *)(vxlan_hdr(skb) + 1), start, offset,
1159			    !!(vxflags & VXLAN_F_REMCSUM_NOPARTIAL));
1160out:
1161	unparsed->vx_flags &= ~VXLAN_HF_RCO;
1162	unparsed->vx_vni &= VXLAN_VNI_MASK;
1163	return true;
1164}
1165
1166static void vxlan_parse_gbp_hdr(struct vxlanhdr *unparsed,
1167				struct sk_buff *skb, u32 vxflags,
1168				struct vxlan_metadata *md)
1169{
1170	struct vxlanhdr_gbp *gbp = (struct vxlanhdr_gbp *)unparsed;
1171	struct metadata_dst *tun_dst;
1172
1173	if (!(unparsed->vx_flags & VXLAN_HF_GBP))
1174		goto out;
1175
1176	md->gbp = ntohs(gbp->policy_id);
1177
1178	tun_dst = (struct metadata_dst *)skb_dst(skb);
1179	if (tun_dst) {
1180		tun_dst->u.tun_info.key.tun_flags |= TUNNEL_VXLAN_OPT;
1181		tun_dst->u.tun_info.options_len = sizeof(*md);
1182	}
1183	if (gbp->dont_learn)
1184		md->gbp |= VXLAN_GBP_DONT_LEARN;
1185
1186	if (gbp->policy_applied)
1187		md->gbp |= VXLAN_GBP_POLICY_APPLIED;
1188
1189	/* In flow-based mode, GBP is carried in dst_metadata */
1190	if (!(vxflags & VXLAN_F_COLLECT_METADATA))
1191		skb->mark = md->gbp;
1192out:
1193	unparsed->vx_flags &= ~VXLAN_GBP_USED_BITS;
1194}
1195
1196static bool vxlan_set_mac(struct vxlan_dev *vxlan,
1197			  struct vxlan_sock *vs,
1198			  struct sk_buff *skb)
1199{
1200	union vxlan_addr saddr;
1201
1202	skb_reset_mac_header(skb);
1203	skb->protocol = eth_type_trans(skb, vxlan->dev);
1204	skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
1205
1206	/* Ignore packet loops (and multicast echo) */
1207	if (ether_addr_equal(eth_hdr(skb)->h_source, vxlan->dev->dev_addr))
1208		return false;
1209
1210	/* Get address from the outer IP header */
1211	if (vxlan_get_sk_family(vs) == AF_INET) {
1212		saddr.sin.sin_addr.s_addr = ip_hdr(skb)->saddr;
1213		saddr.sa.sa_family = AF_INET;
1214#if IS_ENABLED(CONFIG_IPV6)
1215	} else {
1216		saddr.sin6.sin6_addr = ipv6_hdr(skb)->saddr;
1217		saddr.sa.sa_family = AF_INET6;
1218#endif
1219	}
1220
1221	if ((vxlan->flags & VXLAN_F_LEARN) &&
1222	    vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source))
1223		return false;
1224
1225	return true;
1226}
1227
1228static bool vxlan_ecn_decapsulate(struct vxlan_sock *vs, void *oiph,
1229				  struct sk_buff *skb)
1230{
1231	int err = 0;
1232
1233	if (vxlan_get_sk_family(vs) == AF_INET)
1234		err = IP_ECN_decapsulate(oiph, skb);
1235#if IS_ENABLED(CONFIG_IPV6)
1236	else
1237		err = IP6_ECN_decapsulate(oiph, skb);
1238#endif
1239
1240	if (unlikely(err) && log_ecn_error) {
1241		if (vxlan_get_sk_family(vs) == AF_INET)
1242			net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
1243					     &((struct iphdr *)oiph)->saddr,
1244					     ((struct iphdr *)oiph)->tos);
1245		else
1246			net_info_ratelimited("non-ECT from %pI6\n",
1247					     &((struct ipv6hdr *)oiph)->saddr);
1248	}
1249	return err <= 1;
1250}
1251
1252/* Callback from net/ipv4/udp.c to receive packets */
1253static int vxlan_rcv(struct sock *sk, struct sk_buff *skb)
1254{
1255	struct pcpu_sw_netstats *stats;
1256	struct vxlan_dev *vxlan;
1257	struct vxlan_sock *vs;
1258	struct vxlanhdr unparsed;
1259	struct vxlan_metadata _md;
1260	struct vxlan_metadata *md = &_md;
1261	void *oiph;
1262
1263	/* Need Vxlan and inner Ethernet header to be present */
1264	if (!pskb_may_pull(skb, VXLAN_HLEN))
1265		return 1;
1266
1267	unparsed = *vxlan_hdr(skb);
1268	/* VNI flag always required to be set */
1269	if (!(unparsed.vx_flags & VXLAN_HF_VNI)) {
1270		netdev_dbg(skb->dev, "invalid vxlan flags=%#x vni=%#x\n",
1271			   ntohl(vxlan_hdr(skb)->vx_flags),
1272			   ntohl(vxlan_hdr(skb)->vx_vni));
1273		/* Return non vxlan pkt */
1274		return 1;
1275	}
1276	unparsed.vx_flags &= ~VXLAN_HF_VNI;
1277	unparsed.vx_vni &= ~VXLAN_VNI_MASK;
1278
1279	vs = rcu_dereference_sk_user_data(sk);
1280	if (!vs)
1281		goto drop;
1282
1283	vxlan = vxlan_vs_find_vni(vs, vxlan_vni(vxlan_hdr(skb)->vx_vni));
1284	if (!vxlan)
1285		goto drop;
1286
1287	if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB),
1288				 !net_eq(vxlan->net, dev_net(vxlan->dev))))
1289		goto drop;
1290
1291	if (vxlan_collect_metadata(vs)) {
1292		__be32 vni = vxlan_vni(vxlan_hdr(skb)->vx_vni);
1293		struct metadata_dst *tun_dst;
1294
1295		tun_dst = udp_tun_rx_dst(skb, vxlan_get_sk_family(vs), TUNNEL_KEY,
1296					 vxlan_vni_to_tun_id(vni), sizeof(*md));
1297
1298		if (!tun_dst)
1299			goto drop;
1300
1301		md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
1302
1303		skb_dst_set(skb, (struct dst_entry *)tun_dst);
1304	} else {
1305		memset(md, 0, sizeof(*md));
1306	}
1307
1308	/* For backwards compatibility, only allow reserved fields to be
1309	 * used by VXLAN extensions if explicitly requested.
1310	 */
1311	if (vs->flags & VXLAN_F_REMCSUM_RX)
1312		if (!vxlan_remcsum(&unparsed, skb, vs->flags))
1313			goto drop;
1314	if (vs->flags & VXLAN_F_GBP)
1315		vxlan_parse_gbp_hdr(&unparsed, skb, vs->flags, md);
1316
1317	if (unparsed.vx_flags || unparsed.vx_vni) {
1318		/* If there are any unprocessed flags remaining treat
1319		 * this as a malformed packet. This behavior diverges from
1320		 * VXLAN RFC (RFC7348) which stipulates that bits in reserved
1321		 * in reserved fields are to be ignored. The approach here
1322		 * maintains compatibility with previous stack code, and also
1323		 * is more robust and provides a little more security in
1324		 * adding extensions to VXLAN.
1325		 */
1326		goto drop;
1327	}
1328
1329	if (!vxlan_set_mac(vxlan, vs, skb))
1330		goto drop;
1331
1332	oiph = skb_network_header(skb);
1333	skb_reset_network_header(skb);
1334
1335	if (!vxlan_ecn_decapsulate(vs, oiph, skb)) {
1336		++vxlan->dev->stats.rx_frame_errors;
1337		++vxlan->dev->stats.rx_errors;
1338		goto drop;
1339	}
1340
1341	stats = this_cpu_ptr(vxlan->dev->tstats);
1342	u64_stats_update_begin(&stats->syncp);
1343	stats->rx_packets++;
1344	stats->rx_bytes += skb->len;
1345	u64_stats_update_end(&stats->syncp);
1346
1347	gro_cells_receive(&vxlan->gro_cells, skb);
1348	return 0;
1349
1350drop:
1351	/* Consume bad packet */
1352	kfree_skb(skb);
1353	return 0;
1354}
1355
1356static int arp_reduce(struct net_device *dev, struct sk_buff *skb)
1357{
1358	struct vxlan_dev *vxlan = netdev_priv(dev);
1359	struct arphdr *parp;
1360	u8 *arpptr, *sha;
1361	__be32 sip, tip;
1362	struct neighbour *n;
1363
1364	if (dev->flags & IFF_NOARP)
1365		goto out;
1366
1367	if (!pskb_may_pull(skb, arp_hdr_len(dev))) {
1368		dev->stats.tx_dropped++;
1369		goto out;
1370	}
1371	parp = arp_hdr(skb);
1372
1373	if ((parp->ar_hrd != htons(ARPHRD_ETHER) &&
1374	     parp->ar_hrd != htons(ARPHRD_IEEE802)) ||
1375	    parp->ar_pro != htons(ETH_P_IP) ||
1376	    parp->ar_op != htons(ARPOP_REQUEST) ||
1377	    parp->ar_hln != dev->addr_len ||
1378	    parp->ar_pln != 4)
1379		goto out;
1380	arpptr = (u8 *)parp + sizeof(struct arphdr);
1381	sha = arpptr;
1382	arpptr += dev->addr_len;	/* sha */
1383	memcpy(&sip, arpptr, sizeof(sip));
1384	arpptr += sizeof(sip);
1385	arpptr += dev->addr_len;	/* tha */
1386	memcpy(&tip, arpptr, sizeof(tip));
1387
1388	if (ipv4_is_loopback(tip) ||
1389	    ipv4_is_multicast(tip))
1390		goto out;
1391
1392	n = neigh_lookup(&arp_tbl, &tip, dev);
1393
1394	if (n) {
1395		struct vxlan_fdb *f;
1396		struct sk_buff	*reply;
1397
1398		if (!(n->nud_state & NUD_CONNECTED)) {
1399			neigh_release(n);
1400			goto out;
1401		}
1402
1403		f = vxlan_find_mac(vxlan, n->ha);
1404		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
1405			/* bridge-local neighbor */
1406			neigh_release(n);
1407			goto out;
1408		}
1409
1410		reply = arp_create(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
1411				n->ha, sha);
1412
1413		neigh_release(n);
1414
1415		if (reply == NULL)
1416			goto out;
1417
1418		skb_reset_mac_header(reply);
1419		__skb_pull(reply, skb_network_offset(reply));
1420		reply->ip_summed = CHECKSUM_UNNECESSARY;
1421		reply->pkt_type = PACKET_HOST;
1422
1423		if (netif_rx_ni(reply) == NET_RX_DROP)
1424			dev->stats.rx_dropped++;
1425	} else if (vxlan->flags & VXLAN_F_L3MISS) {
1426		union vxlan_addr ipa = {
1427			.sin.sin_addr.s_addr = tip,
1428			.sin.sin_family = AF_INET,
1429		};
1430
1431		vxlan_ip_miss(dev, &ipa);
1432	}
1433out:
1434	consume_skb(skb);
1435	return NETDEV_TX_OK;
1436}
1437
1438#if IS_ENABLED(CONFIG_IPV6)
1439static struct sk_buff *vxlan_na_create(struct sk_buff *request,
1440	struct neighbour *n, bool isrouter)
1441{
1442	struct net_device *dev = request->dev;
1443	struct sk_buff *reply;
1444	struct nd_msg *ns, *na;
1445	struct ipv6hdr *pip6;
1446	u8 *daddr;
1447	int na_olen = 8; /* opt hdr + ETH_ALEN for target */
1448	int ns_olen;
1449	int i, len;
1450
1451	if (dev == NULL)
1452		return NULL;
1453
1454	len = LL_RESERVED_SPACE(dev) + sizeof(struct ipv6hdr) +
1455		sizeof(*na) + na_olen + dev->needed_tailroom;
1456	reply = alloc_skb(len, GFP_ATOMIC);
1457	if (reply == NULL)
1458		return NULL;
1459
1460	reply->protocol = htons(ETH_P_IPV6);
1461	reply->dev = dev;
1462	skb_reserve(reply, LL_RESERVED_SPACE(request->dev));
1463	skb_push(reply, sizeof(struct ethhdr));
1464	skb_reset_mac_header(reply);
1465
1466	ns = (struct nd_msg *)skb_transport_header(request);
1467
1468	daddr = eth_hdr(request)->h_source;
1469	ns_olen = request->len - skb_transport_offset(request) - sizeof(*ns);
1470	for (i = 0; i < ns_olen-1; i += (ns->opt[i+1]<<3)) {
1471		if (ns->opt[i] == ND_OPT_SOURCE_LL_ADDR) {
1472			daddr = ns->opt + i + sizeof(struct nd_opt_hdr);
1473			break;
1474		}
1475	}
1476
1477	/* Ethernet header */
1478	ether_addr_copy(eth_hdr(reply)->h_dest, daddr);
1479	ether_addr_copy(eth_hdr(reply)->h_source, n->ha);
1480	eth_hdr(reply)->h_proto = htons(ETH_P_IPV6);
1481	reply->protocol = htons(ETH_P_IPV6);
1482
1483	skb_pull(reply, sizeof(struct ethhdr));
1484	skb_reset_network_header(reply);
1485	skb_put(reply, sizeof(struct ipv6hdr));
1486
1487	/* IPv6 header */
1488
1489	pip6 = ipv6_hdr(reply);
1490	memset(pip6, 0, sizeof(struct ipv6hdr));
1491	pip6->version = 6;
1492	pip6->priority = ipv6_hdr(request)->priority;
1493	pip6->nexthdr = IPPROTO_ICMPV6;
1494	pip6->hop_limit = 255;
1495	pip6->daddr = ipv6_hdr(request)->saddr;
1496	pip6->saddr = *(struct in6_addr *)n->primary_key;
1497
1498	skb_pull(reply, sizeof(struct ipv6hdr));
1499	skb_reset_transport_header(reply);
1500
1501	na = (struct nd_msg *)skb_put(reply, sizeof(*na) + na_olen);
1502
1503	/* Neighbor Advertisement */
1504	memset(na, 0, sizeof(*na)+na_olen);
1505	na->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;
1506	na->icmph.icmp6_router = isrouter;
1507	na->icmph.icmp6_override = 1;
1508	na->icmph.icmp6_solicited = 1;
1509	na->target = ns->target;
1510	ether_addr_copy(&na->opt[2], n->ha);
1511	na->opt[0] = ND_OPT_TARGET_LL_ADDR;
1512	na->opt[1] = na_olen >> 3;
1513
1514	na->icmph.icmp6_cksum = csum_ipv6_magic(&pip6->saddr,
1515		&pip6->daddr, sizeof(*na)+na_olen, IPPROTO_ICMPV6,
1516		csum_partial(na, sizeof(*na)+na_olen, 0));
1517
1518	pip6->payload_len = htons(sizeof(*na)+na_olen);
1519
1520	skb_push(reply, sizeof(struct ipv6hdr));
1521
1522	reply->ip_summed = CHECKSUM_UNNECESSARY;
1523
1524	return reply;
1525}
1526
1527static int neigh_reduce(struct net_device *dev, struct sk_buff *skb)
1528{
1529	struct vxlan_dev *vxlan = netdev_priv(dev);
1530	struct nd_msg *msg;
1531	const struct ipv6hdr *iphdr;
1532	const struct in6_addr *saddr, *daddr;
1533	struct neighbour *n;
1534	struct inet6_dev *in6_dev;
1535
1536	in6_dev = __in6_dev_get(dev);
1537	if (!in6_dev)
1538		goto out;
1539
1540	iphdr = ipv6_hdr(skb);
1541	saddr = &iphdr->saddr;
1542	daddr = &iphdr->daddr;
1543
1544	msg = (struct nd_msg *)skb_transport_header(skb);
1545	if (msg->icmph.icmp6_code != 0 ||
1546	    msg->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION)
1547		goto out;
1548
1549	if (ipv6_addr_loopback(daddr) ||
1550	    ipv6_addr_is_multicast(&msg->target))
1551		goto out;
1552
1553	n = neigh_lookup(ipv6_stub->nd_tbl, &msg->target, dev);
1554
1555	if (n) {
1556		struct vxlan_fdb *f;
1557		struct sk_buff *reply;
1558
1559		if (!(n->nud_state & NUD_CONNECTED)) {
1560			neigh_release(n);
1561			goto out;
1562		}
1563
1564		f = vxlan_find_mac(vxlan, n->ha);
1565		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
1566			/* bridge-local neighbor */
1567			neigh_release(n);
1568			goto out;
1569		}
1570
1571		reply = vxlan_na_create(skb, n,
1572					!!(f ? f->flags & NTF_ROUTER : 0));
1573
1574		neigh_release(n);
1575
1576		if (reply == NULL)
1577			goto out;
1578
1579		if (netif_rx_ni(reply) == NET_RX_DROP)
1580			dev->stats.rx_dropped++;
1581
1582	} else if (vxlan->flags & VXLAN_F_L3MISS) {
1583		union vxlan_addr ipa = {
1584			.sin6.sin6_addr = msg->target,
1585			.sin6.sin6_family = AF_INET6,
1586		};
1587
1588		vxlan_ip_miss(dev, &ipa);
1589	}
1590
1591out:
1592	consume_skb(skb);
1593	return NETDEV_TX_OK;
1594}
1595#endif
1596
1597static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)
1598{
1599	struct vxlan_dev *vxlan = netdev_priv(dev);
1600	struct neighbour *n;
1601
1602	if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))
1603		return false;
1604
1605	n = NULL;
1606	switch (ntohs(eth_hdr(skb)->h_proto)) {
1607	case ETH_P_IP:
1608	{
1609		struct iphdr *pip;
1610
1611		if (!pskb_may_pull(skb, sizeof(struct iphdr)))
1612			return false;
1613		pip = ip_hdr(skb);
1614		n = neigh_lookup(&arp_tbl, &pip->daddr, dev);
1615		if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
1616			union vxlan_addr ipa = {
1617				.sin.sin_addr.s_addr = pip->daddr,
1618				.sin.sin_family = AF_INET,
1619			};
1620
1621			vxlan_ip_miss(dev, &ipa);
1622			return false;
1623		}
1624
1625		break;
1626	}
1627#if IS_ENABLED(CONFIG_IPV6)
1628	case ETH_P_IPV6:
1629	{
1630		struct ipv6hdr *pip6;
1631
1632		if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
1633			return false;
1634		pip6 = ipv6_hdr(skb);
1635		n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev);
1636		if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
1637			union vxlan_addr ipa = {
1638				.sin6.sin6_addr = pip6->daddr,
1639				.sin6.sin6_family = AF_INET6,
1640			};
1641
1642			vxlan_ip_miss(dev, &ipa);
1643			return false;
1644		}
1645
1646		break;
1647	}
1648#endif
1649	default:
1650		return false;
1651	}
1652
1653	if (n) {
1654		bool diff;
1655
1656		diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);
1657		if (diff) {
1658			memcpy(eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest,
1659				dev->addr_len);
1660			memcpy(eth_hdr(skb)->h_dest, n->ha, dev->addr_len);
1661		}
1662		neigh_release(n);
1663		return diff;
1664	}
1665
1666	return false;
1667}
1668
1669static void vxlan_build_gbp_hdr(struct vxlanhdr *vxh, u32 vxflags,
1670				struct vxlan_metadata *md)
1671{
1672	struct vxlanhdr_gbp *gbp;
1673
1674	if (!md->gbp)
1675		return;
1676
1677	gbp = (struct vxlanhdr_gbp *)vxh;
1678	vxh->vx_flags |= VXLAN_HF_GBP;
1679
1680	if (md->gbp & VXLAN_GBP_DONT_LEARN)
1681		gbp->dont_learn = 1;
1682
1683	if (md->gbp & VXLAN_GBP_POLICY_APPLIED)
1684		gbp->policy_applied = 1;
1685
1686	gbp->policy_id = htons(md->gbp & VXLAN_GBP_ID_MASK);
1687}
1688
1689static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,
1690			   int iphdr_len, __be32 vni,
1691			   struct vxlan_metadata *md, u32 vxflags,
1692			   bool udp_sum)
1693{
1694	struct vxlanhdr *vxh;
1695	int min_headroom;
1696	int err;
1697	int type = udp_sum ? SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
1698
1699	if ((vxflags & VXLAN_F_REMCSUM_TX) &&
1700	    skb->ip_summed == CHECKSUM_PARTIAL) {
1701		int csum_start = skb_checksum_start_offset(skb);
1702
1703		if (csum_start <= VXLAN_MAX_REMCSUM_START &&
1704		    !(csum_start & VXLAN_RCO_SHIFT_MASK) &&
1705		    (skb->csum_offset == offsetof(struct udphdr, check) ||
1706		     skb->csum_offset == offsetof(struct tcphdr, check)))
1707			type |= SKB_GSO_TUNNEL_REMCSUM;
1708	}
1709
1710	min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len
1711			+ VXLAN_HLEN + iphdr_len
1712			+ (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0);
1713
1714	/* Need space for new headers (invalidates iph ptr) */
1715	err = skb_cow_head(skb, min_headroom);
1716	if (unlikely(err)) {
1717		kfree_skb(skb);
1718		return err;
1719	}
1720
1721	skb = vlan_hwaccel_push_inside(skb);
1722	if (WARN_ON(!skb))
1723		return -ENOMEM;
1724
1725	skb = iptunnel_handle_offloads(skb, type);
1726	if (IS_ERR(skb))
1727		return PTR_ERR(skb);
1728
1729	vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
1730	vxh->vx_flags = VXLAN_HF_VNI;
1731	vxh->vx_vni = vxlan_vni_field(vni);
1732
1733	if (type & SKB_GSO_TUNNEL_REMCSUM) {
1734		unsigned int start;
1735
1736		start = skb_checksum_start_offset(skb) - sizeof(struct vxlanhdr);
1737		vxh->vx_vni |= vxlan_compute_rco(start, skb->csum_offset);
1738		vxh->vx_flags |= VXLAN_HF_RCO;
1739
1740		if (!skb_is_gso(skb)) {
1741			skb->ip_summed = CHECKSUM_NONE;
1742			skb->encapsulation = 0;
1743		}
1744	}
1745
1746	if (vxflags & VXLAN_F_GBP)
1747		vxlan_build_gbp_hdr(vxh, vxflags, md);
1748
1749	skb_set_inner_protocol(skb, htons(ETH_P_TEB));
1750	return 0;
1751}
1752
1753static struct rtable *vxlan_get_route(struct vxlan_dev *vxlan,
1754				      struct sk_buff *skb, int oif, u8 tos,
1755				      __be32 daddr, __be32 *saddr,
1756				      struct dst_cache *dst_cache,
1757				      const struct ip_tunnel_info *info)
1758{
1759	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
1760	struct rtable *rt = NULL;
1761	struct flowi4 fl4;
1762
1763	if (tos && !info)
1764		use_cache = false;
1765	if (use_cache) {
1766		rt = dst_cache_get_ip4(dst_cache, saddr);
1767		if (rt)
1768			return rt;
1769	}
1770
1771	memset(&fl4, 0, sizeof(fl4));
1772	fl4.flowi4_oif = oif;
1773	fl4.flowi4_tos = RT_TOS(tos);
1774	fl4.flowi4_mark = skb->mark;
1775	fl4.flowi4_proto = IPPROTO_UDP;
1776	fl4.daddr = daddr;
1777	fl4.saddr = vxlan->cfg.saddr.sin.sin_addr.s_addr;
1778
1779	rt = ip_route_output_key(vxlan->net, &fl4);
1780	if (!IS_ERR(rt)) {
1781		*saddr = fl4.saddr;
1782		if (use_cache)
1783			dst_cache_set_ip4(dst_cache, &rt->dst, fl4.saddr);
1784	}
1785	return rt;
1786}
1787
1788#if IS_ENABLED(CONFIG_IPV6)
1789static struct dst_entry *vxlan6_get_route(struct vxlan_dev *vxlan,
1790					  struct sk_buff *skb, int oif, u8 tos,
1791					  __be32 label,
1792					  const struct in6_addr *daddr,
1793					  struct in6_addr *saddr,
1794					  struct dst_cache *dst_cache,
1795					  const struct ip_tunnel_info *info)
1796{
1797	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
1798	struct dst_entry *ndst;
1799	struct flowi6 fl6;
1800	int err;
1801
1802	if (tos && !info)
1803		use_cache = false;
1804	if (use_cache) {
1805		ndst = dst_cache_get_ip6(dst_cache, saddr);
1806		if (ndst)
1807			return ndst;
1808	}
1809
1810	memset(&fl6, 0, sizeof(fl6));
1811	fl6.flowi6_oif = oif;
1812	fl6.daddr = *daddr;
1813	fl6.saddr = vxlan->cfg.saddr.sin6.sin6_addr;
1814	fl6.flowlabel = ip6_make_flowinfo(RT_TOS(tos), label);
1815	fl6.flowi6_mark = skb->mark;
1816	fl6.flowi6_proto = IPPROTO_UDP;
1817
1818	err = ipv6_stub->ipv6_dst_lookup(vxlan->net,
1819					 vxlan->vn6_sock->sock->sk,
1820					 &ndst, &fl6);
1821	if (err < 0)
1822		return ERR_PTR(err);
1823
1824	*saddr = fl6.saddr;
1825	if (use_cache)
1826		dst_cache_set_ip6(dst_cache, ndst, saddr);
1827	return ndst;
1828}
1829#endif
1830
1831/* Bypass encapsulation if the destination is local */
1832static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan,
1833			       struct vxlan_dev *dst_vxlan)
1834{
1835	struct pcpu_sw_netstats *tx_stats, *rx_stats;
1836	union vxlan_addr loopback;
1837	union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;
1838	struct net_device *dev = skb->dev;
1839	int len = skb->len;
1840
1841	tx_stats = this_cpu_ptr(src_vxlan->dev->tstats);
1842	rx_stats = this_cpu_ptr(dst_vxlan->dev->tstats);
1843	skb->pkt_type = PACKET_HOST;
1844	skb->encapsulation = 0;
1845	skb->dev = dst_vxlan->dev;
1846	__skb_pull(skb, skb_network_offset(skb));
1847
1848	if (remote_ip->sa.sa_family == AF_INET) {
1849		loopback.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1850		loopback.sa.sa_family =  AF_INET;
1851#if IS_ENABLED(CONFIG_IPV6)
1852	} else {
1853		loopback.sin6.sin6_addr = in6addr_loopback;
1854		loopback.sa.sa_family =  AF_INET6;
1855#endif
1856	}
1857
1858	if (dst_vxlan->flags & VXLAN_F_LEARN)
1859		vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source);
1860
1861	u64_stats_update_begin(&tx_stats->syncp);
1862	tx_stats->tx_packets++;
1863	tx_stats->tx_bytes += len;
1864	u64_stats_update_end(&tx_stats->syncp);
1865
1866	if (netif_rx(skb) == NET_RX_SUCCESS) {
1867		u64_stats_update_begin(&rx_stats->syncp);
1868		rx_stats->rx_packets++;
1869		rx_stats->rx_bytes += len;
1870		u64_stats_update_end(&rx_stats->syncp);
1871	} else {
1872		dev->stats.rx_dropped++;
1873	}
1874}
1875
1876static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
1877			   struct vxlan_rdst *rdst, bool did_rsc)
1878{
1879	struct dst_cache *dst_cache;
1880	struct ip_tunnel_info *info;
1881	struct vxlan_dev *vxlan = netdev_priv(dev);
1882	struct sock *sk;
1883	struct rtable *rt = NULL;
1884	const struct iphdr *old_iph;
1885	union vxlan_addr *dst;
1886	union vxlan_addr remote_ip;
1887	struct vxlan_metadata _md;
1888	struct vxlan_metadata *md = &_md;
1889	__be16 src_port = 0, dst_port;
1890	__be32 vni, label;
1891	__be16 df = 0;
1892	__u8 tos, ttl;
1893	int err;
1894	u32 flags = vxlan->flags;
1895	bool udp_sum = false;
1896	bool xnet = !net_eq(vxlan->net, dev_net(vxlan->dev));
1897
1898	info = skb_tunnel_info(skb);
1899
1900	if (rdst) {
1901		dst_port = rdst->remote_port ? rdst->remote_port : vxlan->cfg.dst_port;
1902		vni = rdst->remote_vni;
1903		dst = &rdst->remote_ip;
1904		dst_cache = &rdst->dst_cache;
1905	} else {
1906		if (!info) {
1907			WARN_ONCE(1, "%s: Missing encapsulation instructions\n",
1908				  dev->name);
1909			goto drop;
1910		}
1911		dst_port = info->key.tp_dst ? : vxlan->cfg.dst_port;
1912		vni = vxlan_tun_id_to_vni(info->key.tun_id);
1913		remote_ip.sa.sa_family = ip_tunnel_info_af(info);
1914		if (remote_ip.sa.sa_family == AF_INET)
1915			remote_ip.sin.sin_addr.s_addr = info->key.u.ipv4.dst;
1916		else
1917			remote_ip.sin6.sin6_addr = info->key.u.ipv6.dst;
1918		dst = &remote_ip;
1919		dst_cache = &info->dst_cache;
1920	}
1921
1922	if (vxlan_addr_any(dst)) {
1923		if (did_rsc) {
1924			/* short-circuited back to local bridge */
1925			vxlan_encap_bypass(skb, vxlan, vxlan);
1926			return;
1927		}
1928		goto drop;
1929	}
1930
1931	old_iph = ip_hdr(skb);
1932
1933	ttl = vxlan->cfg.ttl;
1934	if (!ttl && vxlan_addr_multicast(dst))
1935		ttl = 1;
1936
1937	tos = vxlan->cfg.tos;
1938	if (tos == 1)
1939		tos = ip_tunnel_get_dsfield(old_iph, skb);
1940
1941	label = vxlan->cfg.label;
1942	src_port = udp_flow_src_port(dev_net(dev), skb, vxlan->cfg.port_min,
1943				     vxlan->cfg.port_max, true);
1944
1945	if (info) {
1946		ttl = info->key.ttl;
1947		tos = info->key.tos;
1948		label = info->key.label;
1949		udp_sum = !!(info->key.tun_flags & TUNNEL_CSUM);
1950
1951		if (info->options_len)
1952			md = ip_tunnel_info_opts(info);
1953	} else {
1954		md->gbp = skb->mark;
1955	}
1956
1957	if (dst->sa.sa_family == AF_INET) {
1958		__be32 saddr;
1959
1960		if (!vxlan->vn4_sock)
1961			goto drop;
1962		sk = vxlan->vn4_sock->sock->sk;
1963
1964		rt = vxlan_get_route(vxlan, skb,
1965				     rdst ? rdst->remote_ifindex : 0, tos,
1966				     dst->sin.sin_addr.s_addr, &saddr,
1967				     dst_cache, info);
1968		if (IS_ERR(rt)) {
1969			netdev_dbg(dev, "no route to %pI4\n",
1970				   &dst->sin.sin_addr.s_addr);
1971			dev->stats.tx_carrier_errors++;
1972			goto tx_error;
1973		}
1974
1975		if (rt->dst.dev == dev) {
1976			netdev_dbg(dev, "circular route to %pI4\n",
1977				   &dst->sin.sin_addr.s_addr);
1978			dev->stats.collisions++;
1979			goto rt_tx_error;
1980		}
1981
1982		/* Bypass encapsulation if the destination is local */
1983		if (rt->rt_flags & RTCF_LOCAL &&
1984		    !(rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
1985			struct vxlan_dev *dst_vxlan;
1986
1987			ip_rt_put(rt);
1988			dst_vxlan = vxlan_find_vni(vxlan->net, vni,
1989						   dst->sa.sa_family, dst_port,
1990						   vxlan->flags);
1991			if (!dst_vxlan)
1992				goto tx_error;
1993			vxlan_encap_bypass(skb, vxlan, dst_vxlan);
1994			return;
1995		}
1996
1997		if (!info)
1998			udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM_TX);
1999		else if (info->key.tun_flags & TUNNEL_DONT_FRAGMENT)
2000			df = htons(IP_DF);
2001
2002		tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
2003		ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
2004		err = vxlan_build_skb(skb, &rt->dst, sizeof(struct iphdr),
2005				      vni, md, flags, udp_sum);
2006		if (err < 0)
2007			goto xmit_tx_error;
2008
2009		udp_tunnel_xmit_skb(rt, sk, skb, saddr,
2010				    dst->sin.sin_addr.s_addr, tos, ttl, df,
2011				    src_port, dst_port, xnet, !udp_sum);
2012#if IS_ENABLED(CONFIG_IPV6)
2013	} else {
2014		struct dst_entry *ndst;
2015		struct in6_addr saddr;
2016		u32 rt6i_flags;
2017
2018		if (!vxlan->vn6_sock)
2019			goto drop;
2020		sk = vxlan->vn6_sock->sock->sk;
2021
2022		ndst = vxlan6_get_route(vxlan, skb,
2023					rdst ? rdst->remote_ifindex : 0, tos,
2024					label, &dst->sin6.sin6_addr, &saddr,
2025					dst_cache, info);
2026		if (IS_ERR(ndst)) {
2027			netdev_dbg(dev, "no route to %pI6\n",
2028				   &dst->sin6.sin6_addr);
2029			dev->stats.tx_carrier_errors++;
2030			goto tx_error;
2031		}
2032
2033		if (ndst->dev == dev) {
2034			netdev_dbg(dev, "circular route to %pI6\n",
2035				   &dst->sin6.sin6_addr);
2036			dst_release(ndst);
2037			dev->stats.collisions++;
2038			goto tx_error;
2039		}
2040
2041		/* Bypass encapsulation if the destination is local */
2042		rt6i_flags = ((struct rt6_info *)ndst)->rt6i_flags;
2043		if (rt6i_flags & RTF_LOCAL &&
2044		    !(rt6i_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
2045			struct vxlan_dev *dst_vxlan;
2046
2047			dst_release(ndst);
2048			dst_vxlan = vxlan_find_vni(vxlan->net, vni,
2049						   dst->sa.sa_family, dst_port,
2050						   vxlan->flags);
2051			if (!dst_vxlan)
2052				goto tx_error;
2053			vxlan_encap_bypass(skb, vxlan, dst_vxlan);
2054			return;
2055		}
2056
2057		if (!info)
2058			udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM6_TX);
2059
2060		tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
2061		ttl = ttl ? : ip6_dst_hoplimit(ndst);
2062		skb_scrub_packet(skb, xnet);
2063		err = vxlan_build_skb(skb, ndst, sizeof(struct ipv6hdr),
2064				      vni, md, flags, udp_sum);
2065		if (err < 0) {
2066			dst_release(ndst);
2067			return;
2068		}
2069		udp_tunnel6_xmit_skb(ndst, sk, skb, dev,
2070				     &saddr, &dst->sin6.sin6_addr, tos, ttl,
2071				     label, src_port, dst_port, !udp_sum);
2072#endif
2073	}
2074
2075	return;
2076
2077drop:
2078	dev->stats.tx_dropped++;
2079	goto tx_free;
2080
2081xmit_tx_error:
2082	/* skb is already freed. */
2083	skb = NULL;
2084rt_tx_error:
2085	ip_rt_put(rt);
2086tx_error:
2087	dev->stats.tx_errors++;
2088tx_free:
2089	dev_kfree_skb(skb);
2090}
2091
2092/* Transmit local packets over Vxlan
2093 *
2094 * Outer IP header inherits ECN and DF from inner header.
2095 * Outer UDP destination is the VXLAN assigned port.
2096 *           source port is based on hash of flow
2097 */
2098static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)
2099{
2100	struct vxlan_dev *vxlan = netdev_priv(dev);
2101	const struct ip_tunnel_info *info;
2102	struct ethhdr *eth;
2103	bool did_rsc = false;
2104	struct vxlan_rdst *rdst, *fdst = NULL;
2105	struct vxlan_fdb *f;
2106
2107	info = skb_tunnel_info(skb);
2108
2109	skb_reset_mac_header(skb);
2110	eth = eth_hdr(skb);
2111
2112	if ((vxlan->flags & VXLAN_F_PROXY)) {
2113		if (ntohs(eth->h_proto) == ETH_P_ARP)
2114			return arp_reduce(dev, skb);
2115#if IS_ENABLED(CONFIG_IPV6)
2116		else if (ntohs(eth->h_proto) == ETH_P_IPV6 &&
2117			 pskb_may_pull(skb, sizeof(struct ipv6hdr)
2118				       + sizeof(struct nd_msg)) &&
2119			 ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {
2120				struct nd_msg *msg;
2121
2122				msg = (struct nd_msg *)skb_transport_header(skb);
2123				if (msg->icmph.icmp6_code == 0 &&
2124				    msg->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION)
2125					return neigh_reduce(dev, skb);
2126		}
2127		eth = eth_hdr(skb);
2128#endif
2129	}
2130
2131	if (vxlan->flags & VXLAN_F_COLLECT_METADATA) {
2132		if (info && info->mode & IP_TUNNEL_INFO_TX)
2133			vxlan_xmit_one(skb, dev, NULL, false);
2134		else
2135			kfree_skb(skb);
2136		return NETDEV_TX_OK;
2137	}
2138
2139	f = vxlan_find_mac(vxlan, eth->h_dest);
2140	did_rsc = false;
2141
2142	if (f && (f->flags & NTF_ROUTER) && (vxlan->flags & VXLAN_F_RSC) &&
2143	    (ntohs(eth->h_proto) == ETH_P_IP ||
2144	     ntohs(eth->h_proto) == ETH_P_IPV6)) {
2145		did_rsc = route_shortcircuit(dev, skb);
2146		if (did_rsc)
2147			f = vxlan_find_mac(vxlan, eth->h_dest);
2148	}
2149
2150	if (f == NULL) {
2151		f = vxlan_find_mac(vxlan, all_zeros_mac);
2152		if (f == NULL) {
2153			if ((vxlan->flags & VXLAN_F_L2MISS) &&
2154			    !is_multicast_ether_addr(eth->h_dest))
2155				vxlan_fdb_miss(vxlan, eth->h_dest);
2156
2157			dev->stats.tx_dropped++;
2158			kfree_skb(skb);
2159			return NETDEV_TX_OK;
2160		}
2161	}
2162
2163	list_for_each_entry_rcu(rdst, &f->remotes, list) {
2164		struct sk_buff *skb1;
2165
2166		if (!fdst) {
2167			fdst = rdst;
2168			continue;
2169		}
2170		skb1 = skb_clone(skb, GFP_ATOMIC);
2171		if (skb1)
2172			vxlan_xmit_one(skb1, dev, rdst, did_rsc);
2173	}
2174
2175	if (fdst)
2176		vxlan_xmit_one(skb, dev, fdst, did_rsc);
2177	else
2178		kfree_skb(skb);
2179	return NETDEV_TX_OK;
2180}
2181
2182/* Walk the forwarding table and purge stale entries */
2183static void vxlan_cleanup(unsigned long arg)
2184{
2185	struct vxlan_dev *vxlan = (struct vxlan_dev *) arg;
2186	unsigned long next_timer = jiffies + FDB_AGE_INTERVAL;
2187	unsigned int h;
2188
2189	if (!netif_running(vxlan->dev))
2190		return;
2191
2192	for (h = 0; h < FDB_HASH_SIZE; ++h) {
2193		struct hlist_node *p, *n;
2194
2195		spin_lock_bh(&vxlan->hash_lock);
2196		hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
2197			struct vxlan_fdb *f
2198				= container_of(p, struct vxlan_fdb, hlist);
2199			unsigned long timeout;
2200
2201			if (f->state & NUD_PERMANENT)
2202				continue;
2203
2204			timeout = f->used + vxlan->cfg.age_interval * HZ;
2205			if (time_before_eq(timeout, jiffies)) {
2206				netdev_dbg(vxlan->dev,
2207					   "garbage collect %pM\n",
2208					   f->eth_addr);
2209				f->state = NUD_STALE;
2210				vxlan_fdb_destroy(vxlan, f);
2211			} else if (time_before(timeout, next_timer))
2212				next_timer = timeout;
2213		}
2214		spin_unlock_bh(&vxlan->hash_lock);
2215	}
2216
2217	mod_timer(&vxlan->age_timer, next_timer);
2218}
2219
2220static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan)
2221{
2222	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
2223	__be32 vni = vxlan->default_dst.remote_vni;
2224
2225	spin_lock(&vn->sock_lock);
2226	hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));
2227	spin_unlock(&vn->sock_lock);
2228}
2229
2230/* Setup stats when device is created */
2231static int vxlan_init(struct net_device *dev)
2232{
2233	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
2234	if (!dev->tstats)
2235		return -ENOMEM;
2236
2237	return 0;
2238}
2239
2240static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan)
2241{
2242	struct vxlan_fdb *f;
2243
2244	spin_lock_bh(&vxlan->hash_lock);
2245	f = __vxlan_find_mac(vxlan, all_zeros_mac);
2246	if (f)
2247		vxlan_fdb_destroy(vxlan, f);
2248	spin_unlock_bh(&vxlan->hash_lock);
2249}
2250
2251static void vxlan_uninit(struct net_device *dev)
2252{
2253	struct vxlan_dev *vxlan = netdev_priv(dev);
2254
2255	vxlan_fdb_delete_default(vxlan);
2256
2257	free_percpu(dev->tstats);
2258}
2259
2260/* Start ageing timer and join group when device is brought up */
2261static int vxlan_open(struct net_device *dev)
2262{
2263	struct vxlan_dev *vxlan = netdev_priv(dev);
2264	int ret;
2265
2266	ret = vxlan_sock_add(vxlan);
2267	if (ret < 0)
2268		return ret;
2269
2270	if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip)) {
2271		ret = vxlan_igmp_join(vxlan);
2272		if (ret == -EADDRINUSE)
2273			ret = 0;
2274		if (ret) {
2275			vxlan_sock_release(vxlan);
2276			return ret;
2277		}
2278	}
2279
2280	if (vxlan->cfg.age_interval)
2281		mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);
2282
2283	return ret;
2284}
2285
2286/* Purge the forwarding table */
2287static void vxlan_flush(struct vxlan_dev *vxlan)
2288{
2289	unsigned int h;
2290
2291	spin_lock_bh(&vxlan->hash_lock);
2292	for (h = 0; h < FDB_HASH_SIZE; ++h) {
2293		struct hlist_node *p, *n;
2294		hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
2295			struct vxlan_fdb *f
2296				= container_of(p, struct vxlan_fdb, hlist);
2297			/* the all_zeros_mac entry is deleted at vxlan_uninit */
2298			if (!is_zero_ether_addr(f->eth_addr))
2299				vxlan_fdb_destroy(vxlan, f);
2300		}
2301	}
2302	spin_unlock_bh(&vxlan->hash_lock);
2303}
2304
2305/* Cleanup timer and forwarding table on shutdown */
2306static int vxlan_stop(struct net_device *dev)
2307{
2308	struct vxlan_dev *vxlan = netdev_priv(dev);
2309	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
2310	int ret = 0;
2311
2312	if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&
2313	    !vxlan_group_used(vn, vxlan))
2314		ret = vxlan_igmp_leave(vxlan);
2315
2316	del_timer_sync(&vxlan->age_timer);
2317
2318	vxlan_flush(vxlan);
2319	vxlan_sock_release(vxlan);
2320
2321	return ret;
2322}
2323
2324/* Stub, nothing needs to be done. */
2325static void vxlan_set_multicast_list(struct net_device *dev)
2326{
2327}
2328
2329static int __vxlan_change_mtu(struct net_device *dev,
2330			      struct net_device *lowerdev,
2331			      struct vxlan_rdst *dst, int new_mtu, bool strict)
2332{
2333	int max_mtu = IP_MAX_MTU;
2334
2335	if (lowerdev)
2336		max_mtu = lowerdev->mtu;
2337
2338	if (dst->remote_ip.sa.sa_family == AF_INET6)
2339		max_mtu -= VXLAN6_HEADROOM;
2340	else
2341		max_mtu -= VXLAN_HEADROOM;
2342
2343	if (new_mtu < 68)
2344		return -EINVAL;
2345
2346	if (new_mtu > max_mtu) {
2347		if (strict)
2348			return -EINVAL;
2349
2350		new_mtu = max_mtu;
2351	}
2352
2353	dev->mtu = new_mtu;
2354	return 0;
2355}
2356
2357static int vxlan_change_mtu(struct net_device *dev, int new_mtu)
2358{
2359	struct vxlan_dev *vxlan = netdev_priv(dev);
2360	struct vxlan_rdst *dst = &vxlan->default_dst;
2361	struct net_device *lowerdev = __dev_get_by_index(vxlan->net,
2362							 dst->remote_ifindex);
2363	return __vxlan_change_mtu(dev, lowerdev, dst, new_mtu, true);
2364}
2365
2366static int vxlan_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
2367{
2368	struct vxlan_dev *vxlan = netdev_priv(dev);
2369	struct ip_tunnel_info *info = skb_tunnel_info(skb);
2370	__be16 sport, dport;
2371
2372	sport = udp_flow_src_port(dev_net(dev), skb, vxlan->cfg.port_min,
2373				  vxlan->cfg.port_max, true);
2374	dport = info->key.tp_dst ? : vxlan->cfg.dst_port;
2375
2376	if (ip_tunnel_info_af(info) == AF_INET) {
2377		struct rtable *rt;
2378
2379		if (!vxlan->vn4_sock)
2380			return -EINVAL;
2381		rt = vxlan_get_route(vxlan, skb, 0, info->key.tos,
2382				     info->key.u.ipv4.dst,
2383				     &info->key.u.ipv4.src, NULL, info);
2384		if (IS_ERR(rt))
2385			return PTR_ERR(rt);
2386		ip_rt_put(rt);
2387	} else {
2388#if IS_ENABLED(CONFIG_IPV6)
2389		struct dst_entry *ndst;
2390
2391		if (!vxlan->vn6_sock)
2392			return -EINVAL;
2393		ndst = vxlan6_get_route(vxlan, skb, 0, info->key.tos,
2394					info->key.label, &info->key.u.ipv6.dst,
2395					&info->key.u.ipv6.src, NULL, info);
2396		if (IS_ERR(ndst))
2397			return PTR_ERR(ndst);
2398		dst_release(ndst);
2399#else /* !CONFIG_IPV6 */
2400		return -EPFNOSUPPORT;
2401#endif
2402	}
2403	info->key.tp_src = sport;
2404	info->key.tp_dst = dport;
2405	return 0;
2406}
2407
2408static const struct net_device_ops vxlan_netdev_ops = {
2409	.ndo_init		= vxlan_init,
2410	.ndo_uninit		= vxlan_uninit,
2411	.ndo_open		= vxlan_open,
2412	.ndo_stop		= vxlan_stop,
2413	.ndo_start_xmit		= vxlan_xmit,
2414	.ndo_get_stats64	= ip_tunnel_get_stats64,
2415	.ndo_set_rx_mode	= vxlan_set_multicast_list,
2416	.ndo_change_mtu		= vxlan_change_mtu,
2417	.ndo_validate_addr	= eth_validate_addr,
2418	.ndo_set_mac_address	= eth_mac_addr,
2419	.ndo_fdb_add		= vxlan_fdb_add,
2420	.ndo_fdb_del		= vxlan_fdb_delete,
2421	.ndo_fdb_dump		= vxlan_fdb_dump,
2422	.ndo_fill_metadata_dst	= vxlan_fill_metadata_dst,
2423};
2424
2425/* Info for udev, that this is a virtual tunnel endpoint */
2426static struct device_type vxlan_type = {
2427	.name = "vxlan",
2428};
2429
2430/* Calls the ndo_add_vxlan_port of the caller in order to
2431 * supply the listening VXLAN udp ports. Callers are expected
2432 * to implement the ndo_add_vxlan_port.
2433 */
2434void vxlan_get_rx_port(struct net_device *dev)
2435{
2436	struct vxlan_sock *vs;
2437	struct net *net = dev_net(dev);
2438	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2439	sa_family_t sa_family;
2440	__be16 port;
2441	unsigned int i;
2442
2443	spin_lock(&vn->sock_lock);
2444	for (i = 0; i < PORT_HASH_SIZE; ++i) {
2445		hlist_for_each_entry_rcu(vs, &vn->sock_list[i], hlist) {
2446			port = inet_sk(vs->sock->sk)->inet_sport;
2447			sa_family = vxlan_get_sk_family(vs);
2448			dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,
2449							    port);
2450		}
2451	}
2452	spin_unlock(&vn->sock_lock);
2453}
2454EXPORT_SYMBOL_GPL(vxlan_get_rx_port);
2455
2456/* Initialize the device structure. */
2457static void vxlan_setup(struct net_device *dev)
2458{
2459	struct vxlan_dev *vxlan = netdev_priv(dev);
2460	unsigned int h;
2461
2462	eth_hw_addr_random(dev);
2463	ether_setup(dev);
2464
2465	dev->netdev_ops = &vxlan_netdev_ops;
2466	dev->destructor = free_netdev;
2467	SET_NETDEV_DEVTYPE(dev, &vxlan_type);
2468
2469	dev->features	|= NETIF_F_LLTX;
2470	dev->features	|= NETIF_F_SG | NETIF_F_HW_CSUM;
2471	dev->features   |= NETIF_F_RXCSUM;
2472	dev->features   |= NETIF_F_GSO_SOFTWARE;
2473
2474	dev->vlan_features = dev->features;
2475	dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
2476	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
2477	dev->hw_features |= NETIF_F_GSO_SOFTWARE;
2478	dev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
2479	netif_keep_dst(dev);
2480	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
2481	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
2482
2483	INIT_LIST_HEAD(&vxlan->next);
2484	spin_lock_init(&vxlan->hash_lock);
2485
2486	init_timer_deferrable(&vxlan->age_timer);
2487	vxlan->age_timer.function = vxlan_cleanup;
2488	vxlan->age_timer.data = (unsigned long) vxlan;
2489
2490	vxlan->cfg.dst_port = htons(vxlan_port);
2491
2492	vxlan->dev = dev;
2493
2494	gro_cells_init(&vxlan->gro_cells, dev);
2495
2496	for (h = 0; h < FDB_HASH_SIZE; ++h)
2497		INIT_HLIST_HEAD(&vxlan->fdb_head[h]);
2498}
2499
2500static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
2501	[IFLA_VXLAN_ID]		= { .type = NLA_U32 },
2502	[IFLA_VXLAN_GROUP]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
2503	[IFLA_VXLAN_GROUP6]	= { .len = sizeof(struct in6_addr) },
2504	[IFLA_VXLAN_LINK]	= { .type = NLA_U32 },
2505	[IFLA_VXLAN_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
2506	[IFLA_VXLAN_LOCAL6]	= { .len = sizeof(struct in6_addr) },
2507	[IFLA_VXLAN_TOS]	= { .type = NLA_U8 },
2508	[IFLA_VXLAN_TTL]	= { .type = NLA_U8 },
2509	[IFLA_VXLAN_LABEL]	= { .type = NLA_U32 },
2510	[IFLA_VXLAN_LEARNING]	= { .type = NLA_U8 },
2511	[IFLA_VXLAN_AGEING]	= { .type = NLA_U32 },
2512	[IFLA_VXLAN_LIMIT]	= { .type = NLA_U32 },
2513	[IFLA_VXLAN_PORT_RANGE] = { .len  = sizeof(struct ifla_vxlan_port_range) },
2514	[IFLA_VXLAN_PROXY]	= { .type = NLA_U8 },
2515	[IFLA_VXLAN_RSC]	= { .type = NLA_U8 },
2516	[IFLA_VXLAN_L2MISS]	= { .type = NLA_U8 },
2517	[IFLA_VXLAN_L3MISS]	= { .type = NLA_U8 },
2518	[IFLA_VXLAN_COLLECT_METADATA]	= { .type = NLA_U8 },
2519	[IFLA_VXLAN_PORT]	= { .type = NLA_U16 },
2520	[IFLA_VXLAN_UDP_CSUM]	= { .type = NLA_U8 },
2521	[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]	= { .type = NLA_U8 },
2522	[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]	= { .type = NLA_U8 },
2523	[IFLA_VXLAN_REMCSUM_TX]	= { .type = NLA_U8 },
2524	[IFLA_VXLAN_REMCSUM_RX]	= { .type = NLA_U8 },
2525	[IFLA_VXLAN_GBP]	= { .type = NLA_FLAG, },
2526	[IFLA_VXLAN_REMCSUM_NOPARTIAL]	= { .type = NLA_FLAG },
2527};
2528
2529static int vxlan_validate(struct nlattr *tb[], struct nlattr *data[])
2530{
2531	if (tb[IFLA_ADDRESS]) {
2532		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {
2533			pr_debug("invalid link address (not ethernet)\n");
2534			return -EINVAL;
2535		}
2536
2537		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {
2538			pr_debug("invalid all zero ethernet address\n");
2539			return -EADDRNOTAVAIL;
2540		}
2541	}
2542
2543	if (!data)
2544		return -EINVAL;
2545
2546	if (data[IFLA_VXLAN_ID]) {
2547		__u32 id = nla_get_u32(data[IFLA_VXLAN_ID]);
2548		if (id >= VXLAN_VID_MASK)
2549			return -ERANGE;
2550	}
2551
2552	if (data[IFLA_VXLAN_PORT_RANGE]) {
2553		const struct ifla_vxlan_port_range *p
2554			= nla_data(data[IFLA_VXLAN_PORT_RANGE]);
2555
2556		if (ntohs(p->high) < ntohs(p->low)) {
2557			pr_debug("port range %u .. %u not valid\n",
2558				 ntohs(p->low), ntohs(p->high));
2559			return -EINVAL;
2560		}
2561	}
2562
2563	return 0;
2564}
2565
2566static void vxlan_get_drvinfo(struct net_device *netdev,
2567			      struct ethtool_drvinfo *drvinfo)
2568{
2569	strlcpy(drvinfo->version, VXLAN_VERSION, sizeof(drvinfo->version));
2570	strlcpy(drvinfo->driver, "vxlan", sizeof(drvinfo->driver));
2571}
2572
2573static const struct ethtool_ops vxlan_ethtool_ops = {
2574	.get_drvinfo	= vxlan_get_drvinfo,
2575	.get_link	= ethtool_op_get_link,
2576};
2577
2578static void vxlan_del_work(struct work_struct *work)
2579{
2580	struct vxlan_sock *vs = container_of(work, struct vxlan_sock, del_work);
2581	udp_tunnel_sock_release(vs->sock);
2582	kfree_rcu(vs, rcu);
2583}
2584
2585static struct socket *vxlan_create_sock(struct net *net, bool ipv6,
2586					__be16 port, u32 flags)
2587{
2588	struct socket *sock;
2589	struct udp_port_cfg udp_conf;
2590	int err;
2591
2592	memset(&udp_conf, 0, sizeof(udp_conf));
2593
2594	if (ipv6) {
2595		udp_conf.family = AF_INET6;
2596		udp_conf.use_udp6_rx_checksums =
2597		    !(flags & VXLAN_F_UDP_ZERO_CSUM6_RX);
2598		udp_conf.ipv6_v6only = 1;
2599	} else {
2600		udp_conf.family = AF_INET;
2601	}
2602
2603	udp_conf.local_udp_port = port;
2604
2605	/* Open UDP socket */
2606	err = udp_sock_create(net, &udp_conf, &sock);
2607	if (err < 0)
2608		return ERR_PTR(err);
2609
2610	return sock;
2611}
2612
2613/* Create new listen socket if needed */
2614static struct vxlan_sock *vxlan_socket_create(struct net *net, bool ipv6,
2615					      __be16 port, u32 flags)
2616{
2617	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2618	struct vxlan_sock *vs;
2619	struct socket *sock;
2620	unsigned int h;
2621	struct udp_tunnel_sock_cfg tunnel_cfg;
2622
2623	vs = kzalloc(sizeof(*vs), GFP_KERNEL);
2624	if (!vs)
2625		return ERR_PTR(-ENOMEM);
2626
2627	for (h = 0; h < VNI_HASH_SIZE; ++h)
2628		INIT_HLIST_HEAD(&vs->vni_list[h]);
2629
2630	INIT_WORK(&vs->del_work, vxlan_del_work);
2631
2632	sock = vxlan_create_sock(net, ipv6, port, flags);
2633	if (IS_ERR(sock)) {
2634		pr_info("Cannot bind port %d, err=%ld\n", ntohs(port),
2635			PTR_ERR(sock));
2636		kfree(vs);
2637		return ERR_CAST(sock);
2638	}
2639
2640	vs->sock = sock;
2641	atomic_set(&vs->refcnt, 1);
2642	vs->flags = (flags & VXLAN_F_RCV_FLAGS);
2643
2644	/* Initialize the vxlan udp offloads structure */
2645	vs->udp_offloads.port = port;
2646	vs->udp_offloads.callbacks.gro_receive  = vxlan_gro_receive;
2647	vs->udp_offloads.callbacks.gro_complete = vxlan_gro_complete;
2648
2649	spin_lock(&vn->sock_lock);
2650	hlist_add_head_rcu(&vs->hlist, vs_head(net, port));
2651	vxlan_notify_add_rx_port(vs);
2652	spin_unlock(&vn->sock_lock);
2653
2654	/* Mark socket as an encapsulation socket. */
2655	tunnel_cfg.sk_user_data = vs;
2656	tunnel_cfg.encap_type = 1;
2657	tunnel_cfg.encap_rcv = vxlan_rcv;
2658	tunnel_cfg.encap_destroy = NULL;
2659
2660	setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
2661
2662	return vs;
2663}
2664
2665static int __vxlan_sock_add(struct vxlan_dev *vxlan, bool ipv6)
2666{
2667	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
2668	struct vxlan_sock *vs = NULL;
2669
2670	if (!vxlan->cfg.no_share) {
2671		spin_lock(&vn->sock_lock);
2672		vs = vxlan_find_sock(vxlan->net, ipv6 ? AF_INET6 : AF_INET,
2673				     vxlan->cfg.dst_port, vxlan->flags);
2674		if (vs && !atomic_add_unless(&vs->refcnt, 1, 0)) {
2675			spin_unlock(&vn->sock_lock);
2676			return -EBUSY;
2677		}
2678		spin_unlock(&vn->sock_lock);
2679	}
2680	if (!vs)
2681		vs = vxlan_socket_create(vxlan->net, ipv6,
2682					 vxlan->cfg.dst_port, vxlan->flags);
2683	if (IS_ERR(vs))
2684		return PTR_ERR(vs);
2685#if IS_ENABLED(CONFIG_IPV6)
2686	if (ipv6)
2687		vxlan->vn6_sock = vs;
2688	else
2689#endif
2690		vxlan->vn4_sock = vs;
2691	vxlan_vs_add_dev(vs, vxlan);
2692	return 0;
2693}
2694
2695static int vxlan_sock_add(struct vxlan_dev *vxlan)
2696{
2697	bool ipv6 = vxlan->flags & VXLAN_F_IPV6;
2698	bool metadata = vxlan->flags & VXLAN_F_COLLECT_METADATA;
2699	int ret = 0;
2700
2701	vxlan->vn4_sock = NULL;
2702#if IS_ENABLED(CONFIG_IPV6)
2703	vxlan->vn6_sock = NULL;
2704	if (ipv6 || metadata)
2705		ret = __vxlan_sock_add(vxlan, true);
2706#endif
2707	if (!ret && (!ipv6 || metadata))
2708		ret = __vxlan_sock_add(vxlan, false);
2709	if (ret < 0)
2710		vxlan_sock_release(vxlan);
2711	return ret;
2712}
2713
2714static int vxlan_dev_configure(struct net *src_net, struct net_device *dev,
2715			       struct vxlan_config *conf)
2716{
2717	struct vxlan_net *vn = net_generic(src_net, vxlan_net_id);
2718	struct vxlan_dev *vxlan = netdev_priv(dev), *tmp;
2719	struct vxlan_rdst *dst = &vxlan->default_dst;
2720	unsigned short needed_headroom = ETH_HLEN;
2721	int err;
2722	bool use_ipv6 = false;
2723	__be16 default_port = vxlan->cfg.dst_port;
2724	struct net_device *lowerdev = NULL;
2725
2726	vxlan->net = src_net;
2727
2728	dst->remote_vni = conf->vni;
2729
2730	memcpy(&dst->remote_ip, &conf->remote_ip, sizeof(conf->remote_ip));
2731
2732	/* Unless IPv6 is explicitly requested, assume IPv4 */
2733	if (!dst->remote_ip.sa.sa_family)
2734		dst->remote_ip.sa.sa_family = AF_INET;
2735
2736	if (dst->remote_ip.sa.sa_family == AF_INET6 ||
2737	    vxlan->cfg.saddr.sa.sa_family == AF_INET6) {
2738		if (!IS_ENABLED(CONFIG_IPV6))
2739			return -EPFNOSUPPORT;
2740		use_ipv6 = true;
2741		vxlan->flags |= VXLAN_F_IPV6;
2742	}
2743
2744	if (conf->label && !use_ipv6) {
2745		pr_info("label only supported in use with IPv6\n");
2746		return -EINVAL;
2747	}
2748
2749	if (conf->remote_ifindex) {
2750		lowerdev = __dev_get_by_index(src_net, conf->remote_ifindex);
2751		dst->remote_ifindex = conf->remote_ifindex;
2752
2753		if (!lowerdev) {
2754			pr_info("ifindex %d does not exist\n", dst->remote_ifindex);
2755			return -ENODEV;
2756		}
2757
2758#if IS_ENABLED(CONFIG_IPV6)
2759		if (use_ipv6) {
2760			struct inet6_dev *idev = __in6_dev_get(lowerdev);
2761			if (idev && idev->cnf.disable_ipv6) {
2762				pr_info("IPv6 is disabled via sysctl\n");
2763				return -EPERM;
2764			}
2765		}
2766#endif
2767
2768		if (!conf->mtu)
2769			dev->mtu = lowerdev->mtu - (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
2770
2771		needed_headroom = lowerdev->hard_header_len;
2772	}
2773
2774	if (conf->mtu) {
2775		err = __vxlan_change_mtu(dev, lowerdev, dst, conf->mtu, false);
2776		if (err)
2777			return err;
2778	}
2779
2780	if (use_ipv6 || conf->flags & VXLAN_F_COLLECT_METADATA)
2781		needed_headroom += VXLAN6_HEADROOM;
2782	else
2783		needed_headroom += VXLAN_HEADROOM;
2784	dev->needed_headroom = needed_headroom;
2785
2786	memcpy(&vxlan->cfg, conf, sizeof(*conf));
2787	if (!vxlan->cfg.dst_port)
2788		vxlan->cfg.dst_port = default_port;
2789	vxlan->flags |= conf->flags;
2790
2791	if (!vxlan->cfg.age_interval)
2792		vxlan->cfg.age_interval = FDB_AGE_DEFAULT;
2793
2794	list_for_each_entry(tmp, &vn->vxlan_list, next) {
2795		if (tmp->cfg.vni == conf->vni &&
2796		    (tmp->default_dst.remote_ip.sa.sa_family == AF_INET6 ||
2797		     tmp->cfg.saddr.sa.sa_family == AF_INET6) == use_ipv6 &&
2798		    tmp->cfg.dst_port == vxlan->cfg.dst_port &&
2799		    (tmp->flags & VXLAN_F_RCV_FLAGS) ==
2800		    (vxlan->flags & VXLAN_F_RCV_FLAGS))
2801		return -EEXIST;
2802	}
2803
2804	dev->ethtool_ops = &vxlan_ethtool_ops;
2805
2806	/* create an fdb entry for a valid default destination */
2807	if (!vxlan_addr_any(&vxlan->default_dst.remote_ip)) {
2808		err = vxlan_fdb_create(vxlan, all_zeros_mac,
2809				       &vxlan->default_dst.remote_ip,
2810				       NUD_REACHABLE|NUD_PERMANENT,
2811				       NLM_F_EXCL|NLM_F_CREATE,
2812				       vxlan->cfg.dst_port,
2813				       vxlan->default_dst.remote_vni,
2814				       vxlan->default_dst.remote_ifindex,
2815				       NTF_SELF);
2816		if (err)
2817			return err;
2818	}
2819
2820	err = register_netdevice(dev);
2821	if (err) {
2822		vxlan_fdb_delete_default(vxlan);
2823		return err;
2824	}
2825
2826	list_add(&vxlan->next, &vn->vxlan_list);
2827
2828	return 0;
2829}
2830
2831struct net_device *vxlan_dev_create(struct net *net, const char *name,
2832				    u8 name_assign_type, struct vxlan_config *conf)
2833{
2834	struct nlattr *tb[IFLA_MAX+1];
2835	struct net_device *dev;
2836	int err;
2837
2838	memset(&tb, 0, sizeof(tb));
2839
2840	dev = rtnl_create_link(net, name, name_assign_type,
2841			       &vxlan_link_ops, tb);
2842	if (IS_ERR(dev))
2843		return dev;
2844
2845	err = vxlan_dev_configure(net, dev, conf);
2846	if (err < 0) {
2847		free_netdev(dev);
2848		return ERR_PTR(err);
2849	}
2850
2851	return dev;
2852}
2853EXPORT_SYMBOL_GPL(vxlan_dev_create);
2854
2855static int vxlan_newlink(struct net *src_net, struct net_device *dev,
2856			 struct nlattr *tb[], struct nlattr *data[])
2857{
2858	struct vxlan_config conf;
2859	int err;
2860
2861	memset(&conf, 0, sizeof(conf));
2862
2863	if (data[IFLA_VXLAN_ID])
2864		conf.vni = cpu_to_be32(nla_get_u32(data[IFLA_VXLAN_ID]));
2865
2866	if (data[IFLA_VXLAN_GROUP]) {
2867		conf.remote_ip.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_GROUP]);
2868	} else if (data[IFLA_VXLAN_GROUP6]) {
2869		if (!IS_ENABLED(CONFIG_IPV6))
2870			return -EPFNOSUPPORT;
2871
2872		conf.remote_ip.sin6.sin6_addr = nla_get_in6_addr(data[IFLA_VXLAN_GROUP6]);
2873		conf.remote_ip.sa.sa_family = AF_INET6;
2874	}
2875
2876	if (data[IFLA_VXLAN_LOCAL]) {
2877		conf.saddr.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_LOCAL]);
2878		conf.saddr.sa.sa_family = AF_INET;
2879	} else if (data[IFLA_VXLAN_LOCAL6]) {
2880		if (!IS_ENABLED(CONFIG_IPV6))
2881			return -EPFNOSUPPORT;
2882
2883		/* TODO: respect scope id */
2884		conf.saddr.sin6.sin6_addr = nla_get_in6_addr(data[IFLA_VXLAN_LOCAL6]);
2885		conf.saddr.sa.sa_family = AF_INET6;
2886	}
2887
2888	if (data[IFLA_VXLAN_LINK])
2889		conf.remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]);
2890
2891	if (data[IFLA_VXLAN_TOS])
2892		conf.tos  = nla_get_u8(data[IFLA_VXLAN_TOS]);
2893
2894	if (data[IFLA_VXLAN_TTL])
2895		conf.ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);
2896
2897	if (data[IFLA_VXLAN_LABEL])
2898		conf.label = nla_get_be32(data[IFLA_VXLAN_LABEL]) &
2899			     IPV6_FLOWLABEL_MASK;
2900
2901	if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))
2902		conf.flags |= VXLAN_F_LEARN;
2903
2904	if (data[IFLA_VXLAN_AGEING])
2905		conf.age_interval = nla_get_u32(data[IFLA_VXLAN_AGEING]);
2906
2907	if (data[IFLA_VXLAN_PROXY] && nla_get_u8(data[IFLA_VXLAN_PROXY]))
2908		conf.flags |= VXLAN_F_PROXY;
2909
2910	if (data[IFLA_VXLAN_RSC] && nla_get_u8(data[IFLA_VXLAN_RSC]))
2911		conf.flags |= VXLAN_F_RSC;
2912
2913	if (data[IFLA_VXLAN_L2MISS] && nla_get_u8(data[IFLA_VXLAN_L2MISS]))
2914		conf.flags |= VXLAN_F_L2MISS;
2915
2916	if (data[IFLA_VXLAN_L3MISS] && nla_get_u8(data[IFLA_VXLAN_L3MISS]))
2917		conf.flags |= VXLAN_F_L3MISS;
2918
2919	if (data[IFLA_VXLAN_LIMIT])
2920		conf.addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);
2921
2922	if (data[IFLA_VXLAN_COLLECT_METADATA] &&
2923	    nla_get_u8(data[IFLA_VXLAN_COLLECT_METADATA]))
2924		conf.flags |= VXLAN_F_COLLECT_METADATA;
2925
2926	if (data[IFLA_VXLAN_PORT_RANGE]) {
2927		const struct ifla_vxlan_port_range *p
2928			= nla_data(data[IFLA_VXLAN_PORT_RANGE]);
2929		conf.port_min = ntohs(p->low);
2930		conf.port_max = ntohs(p->high);
2931	}
2932
2933	if (data[IFLA_VXLAN_PORT])
2934		conf.dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);
2935
2936	if (data[IFLA_VXLAN_UDP_CSUM] &&
2937	    !nla_get_u8(data[IFLA_VXLAN_UDP_CSUM]))
2938		conf.flags |= VXLAN_F_UDP_ZERO_CSUM_TX;
2939
2940	if (data[IFLA_VXLAN_UDP_ZERO_CSUM6_TX] &&
2941	    nla_get_u8(data[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]))
2942		conf.flags |= VXLAN_F_UDP_ZERO_CSUM6_TX;
2943
2944	if (data[IFLA_VXLAN_UDP_ZERO_CSUM6_RX] &&
2945	    nla_get_u8(data[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]))
2946		conf.flags |= VXLAN_F_UDP_ZERO_CSUM6_RX;
2947
2948	if (data[IFLA_VXLAN_REMCSUM_TX] &&
2949	    nla_get_u8(data[IFLA_VXLAN_REMCSUM_TX]))
2950		conf.flags |= VXLAN_F_REMCSUM_TX;
2951
2952	if (data[IFLA_VXLAN_REMCSUM_RX] &&
2953	    nla_get_u8(data[IFLA_VXLAN_REMCSUM_RX]))
2954		conf.flags |= VXLAN_F_REMCSUM_RX;
2955
2956	if (data[IFLA_VXLAN_GBP])
2957		conf.flags |= VXLAN_F_GBP;
2958
2959	if (data[IFLA_VXLAN_REMCSUM_NOPARTIAL])
2960		conf.flags |= VXLAN_F_REMCSUM_NOPARTIAL;
2961
2962	err = vxlan_dev_configure(src_net, dev, &conf);
2963	switch (err) {
2964	case -ENODEV:
2965		pr_info("ifindex %d does not exist\n", conf.remote_ifindex);
2966		break;
2967
2968	case -EPERM:
2969		pr_info("IPv6 is disabled via sysctl\n");
2970		break;
2971
2972	case -EEXIST:
2973		pr_info("duplicate VNI %u\n", be32_to_cpu(conf.vni));
2974		break;
2975	}
2976
2977	return err;
2978}
2979
2980static void vxlan_dellink(struct net_device *dev, struct list_head *head)
2981{
2982	struct vxlan_dev *vxlan = netdev_priv(dev);
2983	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);
2984
2985	spin_lock(&vn->sock_lock);
2986	if (!hlist_unhashed(&vxlan->hlist))
2987		hlist_del_rcu(&vxlan->hlist);
2988	spin_unlock(&vn->sock_lock);
2989
2990	gro_cells_destroy(&vxlan->gro_cells);
2991	list_del(&vxlan->next);
2992	unregister_netdevice_queue(dev, head);
2993}
2994
2995static size_t vxlan_get_size(const struct net_device *dev)
2996{
2997
2998	return nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_ID */
2999		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */
3000		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LINK */
3001		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */
3002		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TTL */
3003		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TOS */
3004		nla_total_size(sizeof(__be32)) + /* IFLA_VXLAN_LABEL */
3005		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_LEARNING */
3006		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_PROXY */
3007		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_RSC */
3008		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_L2MISS */
3009		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_L3MISS */
3010		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_COLLECT_METADATA */
3011		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_AGEING */
3012		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LIMIT */
3013		nla_total_size(sizeof(struct ifla_vxlan_port_range)) +
3014		nla_total_size(sizeof(__be16)) + /* IFLA_VXLAN_PORT */
3015		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_CSUM */
3016		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_ZERO_CSUM6_TX */
3017		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_ZERO_CSUM6_RX */
3018		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_TX */
3019		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_RX */
3020		0;
3021}
3022
3023static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
3024{
3025	const struct vxlan_dev *vxlan = netdev_priv(dev);
3026	const struct vxlan_rdst *dst = &vxlan->default_dst;
3027	struct ifla_vxlan_port_range ports = {
3028		.low =  htons(vxlan->cfg.port_min),
3029		.high = htons(vxlan->cfg.port_max),
3030	};
3031
3032	if (nla_put_u32(skb, IFLA_VXLAN_ID, be32_to_cpu(dst->remote_vni)))
3033		goto nla_put_failure;
3034
3035	if (!vxlan_addr_any(&dst->remote_ip)) {
3036		if (dst->remote_ip.sa.sa_family == AF_INET) {
3037			if (nla_put_in_addr(skb, IFLA_VXLAN_GROUP,
3038					    dst->remote_ip.sin.sin_addr.s_addr))
3039				goto nla_put_failure;
3040#if IS_ENABLED(CONFIG_IPV6)
3041		} else {
3042			if (nla_put_in6_addr(skb, IFLA_VXLAN_GROUP6,
3043					     &dst->remote_ip.sin6.sin6_addr))
3044				goto nla_put_failure;
3045#endif
3046		}
3047	}
3048
3049	if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))
3050		goto nla_put_failure;
3051
3052	if (!vxlan_addr_any(&vxlan->cfg.saddr)) {
3053		if (vxlan->cfg.saddr.sa.sa_family == AF_INET) {
3054			if (nla_put_in_addr(skb, IFLA_VXLAN_LOCAL,
3055					    vxlan->cfg.saddr.sin.sin_addr.s_addr))
3056				goto nla_put_failure;
3057#if IS_ENABLED(CONFIG_IPV6)
3058		} else {
3059			if (nla_put_in6_addr(skb, IFLA_VXLAN_LOCAL6,
3060					     &vxlan->cfg.saddr.sin6.sin6_addr))
3061				goto nla_put_failure;
3062#endif
3063		}
3064	}
3065
3066	if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->cfg.ttl) ||
3067	    nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->cfg.tos) ||
3068	    nla_put_be32(skb, IFLA_VXLAN_LABEL, vxlan->cfg.label) ||
3069	    nla_put_u8(skb, IFLA_VXLAN_LEARNING,
3070			!!(vxlan->flags & VXLAN_F_LEARN)) ||
3071	    nla_put_u8(skb, IFLA_VXLAN_PROXY,
3072			!!(vxlan->flags & VXLAN_F_PROXY)) ||
3073	    nla_put_u8(skb, IFLA_VXLAN_RSC, !!(vxlan->flags & VXLAN_F_RSC)) ||
3074	    nla_put_u8(skb, IFLA_VXLAN_L2MISS,
3075			!!(vxlan->flags & VXLAN_F_L2MISS)) ||
3076	    nla_put_u8(skb, IFLA_VXLAN_L3MISS,
3077			!!(vxlan->flags & VXLAN_F_L3MISS)) ||
3078	    nla_put_u8(skb, IFLA_VXLAN_COLLECT_METADATA,
3079		       !!(vxlan->flags & VXLAN_F_COLLECT_METADATA)) ||
3080	    nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->cfg.age_interval) ||
3081	    nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->cfg.addrmax) ||
3082	    nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->cfg.dst_port) ||
3083	    nla_put_u8(skb, IFLA_VXLAN_UDP_CSUM,
3084			!(vxlan->flags & VXLAN_F_UDP_ZERO_CSUM_TX)) ||
3085	    nla_put_u8(skb, IFLA_VXLAN_UDP_ZERO_CSUM6_TX,
3086			!!(vxlan->flags & VXLAN_F_UDP_ZERO_CSUM6_TX)) ||
3087	    nla_put_u8(skb, IFLA_VXLAN_UDP_ZERO_CSUM6_RX,
3088			!!(vxlan->flags & VXLAN_F_UDP_ZERO_CSUM6_RX)) ||
3089	    nla_put_u8(skb, IFLA_VXLAN_REMCSUM_TX,
3090			!!(vxlan->flags & VXLAN_F_REMCSUM_TX)) ||
3091	    nla_put_u8(skb, IFLA_VXLAN_REMCSUM_RX,
3092			!!(vxlan->flags & VXLAN_F_REMCSUM_RX)))
3093		goto nla_put_failure;
3094
3095	if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))
3096		goto nla_put_failure;
3097
3098	if (vxlan->flags & VXLAN_F_GBP &&
3099	    nla_put_flag(skb, IFLA_VXLAN_GBP))
3100		goto nla_put_failure;
3101
3102	if (vxlan->flags & VXLAN_F_REMCSUM_NOPARTIAL &&
3103	    nla_put_flag(skb, IFLA_VXLAN_REMCSUM_NOPARTIAL))
3104		goto nla_put_failure;
3105
3106	return 0;
3107
3108nla_put_failure:
3109	return -EMSGSIZE;
3110}
3111
3112static struct net *vxlan_get_link_net(const struct net_device *dev)
3113{
3114	struct vxlan_dev *vxlan = netdev_priv(dev);
3115
3116	return vxlan->net;
3117}
3118
3119static struct rtnl_link_ops vxlan_link_ops __read_mostly = {
3120	.kind		= "vxlan",
3121	.maxtype	= IFLA_VXLAN_MAX,
3122	.policy		= vxlan_policy,
3123	.priv_size	= sizeof(struct vxlan_dev),
3124	.setup		= vxlan_setup,
3125	.validate	= vxlan_validate,
3126	.newlink	= vxlan_newlink,
3127	.dellink	= vxlan_dellink,
3128	.get_size	= vxlan_get_size,
3129	.fill_info	= vxlan_fill_info,
3130	.get_link_net	= vxlan_get_link_net,
3131};
3132
3133static void vxlan_handle_lowerdev_unregister(struct vxlan_net *vn,
3134					     struct net_device *dev)
3135{
3136	struct vxlan_dev *vxlan, *next;
3137	LIST_HEAD(list_kill);
3138
3139	list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next) {
3140		struct vxlan_rdst *dst = &vxlan->default_dst;
3141
3142		/* In case we created vxlan device with carrier
3143		 * and we loose the carrier due to module unload
3144		 * we also need to remove vxlan device. In other
3145		 * cases, it's not necessary and remote_ifindex
3146		 * is 0 here, so no matches.
3147		 */
3148		if (dst->remote_ifindex == dev->ifindex)
3149			vxlan_dellink(vxlan->dev, &list_kill);
3150	}
3151
3152	unregister_netdevice_many(&list_kill);
3153}
3154
3155static int vxlan_lowerdev_event(struct notifier_block *unused,
3156				unsigned long event, void *ptr)
3157{
3158	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3159	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
3160
3161	if (event == NETDEV_UNREGISTER)
3162		vxlan_handle_lowerdev_unregister(vn, dev);
3163
3164	return NOTIFY_DONE;
3165}
3166
3167static struct notifier_block vxlan_notifier_block __read_mostly = {
3168	.notifier_call = vxlan_lowerdev_event,
3169};
3170
3171static __net_init int vxlan_init_net(struct net *net)
3172{
3173	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
3174	unsigned int h;
3175
3176	INIT_LIST_HEAD(&vn->vxlan_list);
3177	spin_lock_init(&vn->sock_lock);
3178
3179	for (h = 0; h < PORT_HASH_SIZE; ++h)
3180		INIT_HLIST_HEAD(&vn->sock_list[h]);
3181
3182	return 0;
3183}
3184
3185static void __net_exit vxlan_exit_net(struct net *net)
3186{
3187	struct vxlan_net *vn = net_generic(net, vxlan_net_id);
3188	struct vxlan_dev *vxlan, *next;
3189	struct net_device *dev, *aux;
3190	LIST_HEAD(list);
3191
3192	rtnl_lock();
3193	for_each_netdev_safe(net, dev, aux)
3194		if (dev->rtnl_link_ops == &vxlan_link_ops)
3195			unregister_netdevice_queue(dev, &list);
3196
3197	list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next) {
3198		/* If vxlan->dev is in the same netns, it has already been added
3199		 * to the list by the previous loop.
3200		 */
3201		if (!net_eq(dev_net(vxlan->dev), net)) {
3202			gro_cells_destroy(&vxlan->gro_cells);
3203			unregister_netdevice_queue(vxlan->dev, &list);
3204		}
3205	}
3206
3207	unregister_netdevice_many(&list);
3208	rtnl_unlock();
3209}
3210
3211static struct pernet_operations vxlan_net_ops = {
3212	.init = vxlan_init_net,
3213	.exit = vxlan_exit_net,
3214	.id   = &vxlan_net_id,
3215	.size = sizeof(struct vxlan_net),
3216};
3217
3218static int __init vxlan_init_module(void)
3219{
3220	int rc;
3221
3222	vxlan_wq = alloc_workqueue("vxlan", 0, 0);
3223	if (!vxlan_wq)
3224		return -ENOMEM;
3225
3226	get_random_bytes(&vxlan_salt, sizeof(vxlan_salt));
3227
3228	rc = register_pernet_subsys(&vxlan_net_ops);
3229	if (rc)
3230		goto out1;
3231
3232	rc = register_netdevice_notifier(&vxlan_notifier_block);
3233	if (rc)
3234		goto out2;
3235
3236	rc = rtnl_link_register(&vxlan_link_ops);
3237	if (rc)
3238		goto out3;
3239
3240	return 0;
3241out3:
3242	unregister_netdevice_notifier(&vxlan_notifier_block);
3243out2:
3244	unregister_pernet_subsys(&vxlan_net_ops);
3245out1:
3246	destroy_workqueue(vxlan_wq);
3247	return rc;
3248}
3249late_initcall(vxlan_init_module);
3250
3251static void __exit vxlan_cleanup_module(void)
3252{
3253	rtnl_link_unregister(&vxlan_link_ops);
3254	unregister_netdevice_notifier(&vxlan_notifier_block);
3255	destroy_workqueue(vxlan_wq);
3256	unregister_pernet_subsys(&vxlan_net_ops);
3257	/* rcu_barrier() is called by netns */
3258}
3259module_exit(vxlan_cleanup_module);
3260
3261MODULE_LICENSE("GPL");
3262MODULE_VERSION(VXLAN_VERSION);
3263MODULE_AUTHOR("Stephen Hemminger <stephen@networkplumber.org>");
3264MODULE_DESCRIPTION("Driver for VXLAN encapsulated traffic");
3265MODULE_ALIAS_RTNL_LINK("vxlan");