brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-only2/*3 * VXLAN: Virtual eXtensible Local Area Network4 *5 * Copyright (c) 2012-2013 Vyatta Inc.6 */7 8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt9 10#include <linux/kernel.h>11#include <linux/module.h>12#include <linux/errno.h>13#include <linux/slab.h>14#include <linux/udp.h>15#include <linux/igmp.h>16#include <linux/if_ether.h>17#include <linux/ethtool.h>18#include <net/arp.h>19#include <net/ndisc.h>20#include <net/gro.h>21#include <net/ipv6_stubs.h>22#include <net/ip.h>23#include <net/icmp.h>24#include <net/rtnetlink.h>25#include <net/inet_ecn.h>26#include <net/net_namespace.h>27#include <net/netns/generic.h>28#include <net/tun_proto.h>29#include <net/vxlan.h>30#include <net/nexthop.h>31 32#if IS_ENABLED(CONFIG_IPV6)33#include <net/ip6_tunnel.h>34#include <net/ip6_checksum.h>35#endif36 37#include "vxlan_private.h"38 39#define VXLAN_VERSION	"0.1"40 41#define FDB_AGE_DEFAULT 300 /* 5 min */42#define FDB_AGE_INTERVAL (10 * HZ)	/* rescan interval */43 44/* UDP port for VXLAN traffic.45 * The IANA assigned port is 4789, but the Linux default is 847246 * for compatibility with early adopters.47 */48static unsigned short vxlan_port __read_mostly = 8472;49module_param_named(udp_port, vxlan_port, ushort, 0444);50MODULE_PARM_DESC(udp_port, "Destination UDP port");51 52static bool log_ecn_error = true;53module_param(log_ecn_error, bool, 0644);54MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");55 56unsigned int vxlan_net_id;57 58const u8 all_zeros_mac[ETH_ALEN + 2];59static struct rtnl_link_ops vxlan_link_ops;60 61static int vxlan_sock_add(struct vxlan_dev *vxlan);62 63static void vxlan_vs_del_dev(struct vxlan_dev *vxlan);64 65/* salt for hash table */66static u32 vxlan_salt __read_mostly;67 68static inline bool vxlan_collect_metadata(struct vxlan_sock *vs)69{70	return vs->flags & VXLAN_F_COLLECT_METADATA ||71	       ip_tunnel_collect_metadata();72}73 74/* Find VXLAN socket based on network namespace, address family, UDP port,75 * enabled unshareable flags and socket device binding (see l3mdev with76 * non-default VRF).77 */78static struct vxlan_sock *vxlan_find_sock(struct net *net, sa_family_t family,79					  __be16 port, u32 flags, int ifindex)80{81	struct vxlan_sock *vs;82 83	flags &= VXLAN_F_RCV_FLAGS;84 85	hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {86		if (inet_sk(vs->sock->sk)->inet_sport == port &&87		    vxlan_get_sk_family(vs) == family &&88		    vs->flags == flags &&89		    vs->sock->sk->sk_bound_dev_if == ifindex)90			return vs;91	}92	return NULL;93}94 95static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs,96					   int ifindex, __be32 vni,97					   struct vxlan_vni_node **vninode)98{99	struct vxlan_vni_node *vnode;100	struct vxlan_dev_node *node;101 102	/* For flow based devices, map all packets to VNI 0 */103	if (vs->flags & VXLAN_F_COLLECT_METADATA &&104	    !(vs->flags & VXLAN_F_VNIFILTER))105		vni = 0;106 107	hlist_for_each_entry_rcu(node, vni_head(vs, vni), hlist) {108		if (!node->vxlan)109			continue;110		vnode = NULL;111		if (node->vxlan->cfg.flags & VXLAN_F_VNIFILTER) {112			vnode = vxlan_vnifilter_lookup(node->vxlan, vni);113			if (!vnode)114				continue;115		} else if (node->vxlan->default_dst.remote_vni != vni) {116			continue;117		}118 119		if (IS_ENABLED(CONFIG_IPV6)) {120			const struct vxlan_config *cfg = &node->vxlan->cfg;121 122			if ((cfg->flags & VXLAN_F_IPV6_LINKLOCAL) &&123			    cfg->remote_ifindex != ifindex)124				continue;125		}126 127		if (vninode)128			*vninode = vnode;129		return node->vxlan;130	}131 132	return NULL;133}134 135/* Look up VNI in a per net namespace table */136static struct vxlan_dev *vxlan_find_vni(struct net *net, int ifindex,137					__be32 vni, sa_family_t family,138					__be16 port, u32 flags)139{140	struct vxlan_sock *vs;141 142	vs = vxlan_find_sock(net, family, port, flags, ifindex);143	if (!vs)144		return NULL;145 146	return vxlan_vs_find_vni(vs, ifindex, vni, NULL);147}148 149/* Fill in neighbour message in skbuff. */150static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,151			  const struct vxlan_fdb *fdb,152			  u32 portid, u32 seq, int type, unsigned int flags,153			  const struct vxlan_rdst *rdst)154{155	unsigned long now = jiffies;156	struct nda_cacheinfo ci;157	bool send_ip, send_eth;158	struct nlmsghdr *nlh;159	struct nexthop *nh;160	struct ndmsg *ndm;161	int nh_family;162	u32 nh_id;163 164	nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);165	if (nlh == NULL)166		return -EMSGSIZE;167 168	ndm = nlmsg_data(nlh);169	memset(ndm, 0, sizeof(*ndm));170 171	send_eth = send_ip = true;172 173	rcu_read_lock();174	nh = rcu_dereference(fdb->nh);175	if (nh) {176		nh_family = nexthop_get_family(nh);177		nh_id = nh->id;178	}179	rcu_read_unlock();180 181	if (type == RTM_GETNEIGH) {182		if (rdst) {183			send_ip = !vxlan_addr_any(&rdst->remote_ip);184			ndm->ndm_family = send_ip ? rdst->remote_ip.sa.sa_family : AF_INET;185		} else if (nh) {186			ndm->ndm_family = nh_family;187		}188		send_eth = !is_zero_ether_addr(fdb->eth_addr);189	} else190		ndm->ndm_family	= AF_BRIDGE;191	ndm->ndm_state = fdb->state;192	ndm->ndm_ifindex = vxlan->dev->ifindex;193	ndm->ndm_flags = fdb->flags;194	if (rdst && rdst->offloaded)195		ndm->ndm_flags |= NTF_OFFLOADED;196	ndm->ndm_type = RTN_UNICAST;197 198	if (!net_eq(dev_net(vxlan->dev), vxlan->net) &&199	    nla_put_s32(skb, NDA_LINK_NETNSID,200			peernet2id(dev_net(vxlan->dev), vxlan->net)))201		goto nla_put_failure;202 203	if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))204		goto nla_put_failure;205	if (nh) {206		if (nla_put_u32(skb, NDA_NH_ID, nh_id))207			goto nla_put_failure;208	} else if (rdst) {209		if (send_ip && vxlan_nla_put_addr(skb, NDA_DST,210						  &rdst->remote_ip))211			goto nla_put_failure;212 213		if (rdst->remote_port &&214		    rdst->remote_port != vxlan->cfg.dst_port &&215		    nla_put_be16(skb, NDA_PORT, rdst->remote_port))216			goto nla_put_failure;217		if (rdst->remote_vni != vxlan->default_dst.remote_vni &&218		    nla_put_u32(skb, NDA_VNI, be32_to_cpu(rdst->remote_vni)))219			goto nla_put_failure;220		if (rdst->remote_ifindex &&221		    nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))222			goto nla_put_failure;223	}224 225	if ((vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) && fdb->vni &&226	    nla_put_u32(skb, NDA_SRC_VNI,227			be32_to_cpu(fdb->vni)))228		goto nla_put_failure;229 230	ci.ndm_used	 = jiffies_to_clock_t(now - fdb->used);231	ci.ndm_confirmed = 0;232	ci.ndm_updated	 = jiffies_to_clock_t(now - fdb->updated);233	ci.ndm_refcnt	 = 0;234 235	if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))236		goto nla_put_failure;237 238	nlmsg_end(skb, nlh);239	return 0;240 241nla_put_failure:242	nlmsg_cancel(skb, nlh);243	return -EMSGSIZE;244}245 246static inline size_t vxlan_nlmsg_size(void)247{248	return NLMSG_ALIGN(sizeof(struct ndmsg))249		+ nla_total_size(ETH_ALEN) /* NDA_LLADDR */250		+ nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */251		+ nla_total_size(sizeof(__be16)) /* NDA_PORT */252		+ nla_total_size(sizeof(__be32)) /* NDA_VNI */253		+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */254		+ nla_total_size(sizeof(__s32)) /* NDA_LINK_NETNSID */255		+ nla_total_size(sizeof(struct nda_cacheinfo));256}257 258static void __vxlan_fdb_notify(struct vxlan_dev *vxlan, struct vxlan_fdb *fdb,259			       struct vxlan_rdst *rd, int type)260{261	struct net *net = dev_net(vxlan->dev);262	struct sk_buff *skb;263	int err = -ENOBUFS;264 265	skb = nlmsg_new(vxlan_nlmsg_size(), GFP_ATOMIC);266	if (skb == NULL)267		goto errout;268 269	err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0, rd);270	if (err < 0) {271		/* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */272		WARN_ON(err == -EMSGSIZE);273		kfree_skb(skb);274		goto errout;275	}276 277	rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);278	return;279errout:280	rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);281}282 283static void vxlan_fdb_switchdev_notifier_info(const struct vxlan_dev *vxlan,284			    const struct vxlan_fdb *fdb,285			    const struct vxlan_rdst *rd,286			    struct netlink_ext_ack *extack,287			    struct switchdev_notifier_vxlan_fdb_info *fdb_info)288{289	fdb_info->info.dev = vxlan->dev;290	fdb_info->info.extack = extack;291	fdb_info->remote_ip = rd->remote_ip;292	fdb_info->remote_port = rd->remote_port;293	fdb_info->remote_vni = rd->remote_vni;294	fdb_info->remote_ifindex = rd->remote_ifindex;295	memcpy(fdb_info->eth_addr, fdb->eth_addr, ETH_ALEN);296	fdb_info->vni = fdb->vni;297	fdb_info->offloaded = rd->offloaded;298	fdb_info->added_by_user = fdb->flags & NTF_VXLAN_ADDED_BY_USER;299}300 301static int vxlan_fdb_switchdev_call_notifiers(struct vxlan_dev *vxlan,302					      struct vxlan_fdb *fdb,303					      struct vxlan_rdst *rd,304					      bool adding,305					      struct netlink_ext_ack *extack)306{307	struct switchdev_notifier_vxlan_fdb_info info;308	enum switchdev_notifier_type notifier_type;309	int ret;310 311	if (WARN_ON(!rd))312		return 0;313 314	notifier_type = adding ? SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE315			       : SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE;316	vxlan_fdb_switchdev_notifier_info(vxlan, fdb, rd, NULL, &info);317	ret = call_switchdev_notifiers(notifier_type, vxlan->dev,318				       &info.info, extack);319	return notifier_to_errno(ret);320}321 322static int vxlan_fdb_notify(struct vxlan_dev *vxlan, struct vxlan_fdb *fdb,323			    struct vxlan_rdst *rd, int type, bool swdev_notify,324			    struct netlink_ext_ack *extack)325{326	int err;327 328	if (swdev_notify && rd) {329		switch (type) {330		case RTM_NEWNEIGH:331			err = vxlan_fdb_switchdev_call_notifiers(vxlan, fdb, rd,332								 true, extack);333			if (err)334				return err;335			break;336		case RTM_DELNEIGH:337			vxlan_fdb_switchdev_call_notifiers(vxlan, fdb, rd,338							   false, extack);339			break;340		}341	}342 343	__vxlan_fdb_notify(vxlan, fdb, rd, type);344	return 0;345}346 347static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)348{349	struct vxlan_dev *vxlan = netdev_priv(dev);350	struct vxlan_fdb f = {351		.state = NUD_STALE,352	};353	struct vxlan_rdst remote = {354		.remote_ip = *ipa, /* goes to NDA_DST */355		.remote_vni = cpu_to_be32(VXLAN_N_VID),356	};357 358	vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH, true, NULL);359}360 361static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])362{363	struct vxlan_fdb f = {364		.state = NUD_STALE,365	};366	struct vxlan_rdst remote = { };367 368	memcpy(f.eth_addr, eth_addr, ETH_ALEN);369 370	vxlan_fdb_notify(vxlan, &f, &remote, RTM_GETNEIGH, true, NULL);371}372 373/* Hash Ethernet address */374static u32 eth_hash(const unsigned char *addr)375{376	u64 value = get_unaligned((u64 *)addr);377 378	/* only want 6 bytes */379#ifdef __BIG_ENDIAN380	value >>= 16;381#else382	value <<= 16;383#endif384	return hash_64(value, FDB_HASH_BITS);385}386 387u32 eth_vni_hash(const unsigned char *addr, __be32 vni)388{389	/* use 1 byte of OUI and 3 bytes of NIC */390	u32 key = get_unaligned((u32 *)(addr + 2));391 392	return jhash_2words(key, vni, vxlan_salt) & (FDB_HASH_SIZE - 1);393}394 395u32 fdb_head_index(struct vxlan_dev *vxlan, const u8 *mac, __be32 vni)396{397	if (vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA)398		return eth_vni_hash(mac, vni);399	else400		return eth_hash(mac);401}402 403/* Hash chain to use given mac address */404static inline struct hlist_head *vxlan_fdb_head(struct vxlan_dev *vxlan,405						const u8 *mac, __be32 vni)406{407	return &vxlan->fdb_head[fdb_head_index(vxlan, mac, vni)];408}409 410/* Look up Ethernet address in forwarding table */411static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,412					  const u8 *mac, __be32 vni)413{414	struct hlist_head *head = vxlan_fdb_head(vxlan, mac, vni);415	struct vxlan_fdb *f;416 417	hlist_for_each_entry_rcu(f, head, hlist) {418		if (ether_addr_equal(mac, f->eth_addr)) {419			if (vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) {420				if (vni == f->vni)421					return f;422			} else {423				return f;424			}425		}426	}427 428	return NULL;429}430 431static struct vxlan_fdb *vxlan_find_mac(struct vxlan_dev *vxlan,432					const u8 *mac, __be32 vni)433{434	struct vxlan_fdb *f;435 436	f = __vxlan_find_mac(vxlan, mac, vni);437	if (f && f->used != jiffies)438		f->used = jiffies;439 440	return f;441}442 443/* caller should hold vxlan->hash_lock */444static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,445					      union vxlan_addr *ip, __be16 port,446					      __be32 vni, __u32 ifindex)447{448	struct vxlan_rdst *rd;449 450	list_for_each_entry(rd, &f->remotes, list) {451		if (vxlan_addr_equal(&rd->remote_ip, ip) &&452		    rd->remote_port == port &&453		    rd->remote_vni == vni &&454		    rd->remote_ifindex == ifindex)455			return rd;456	}457 458	return NULL;459}460 461int vxlan_fdb_find_uc(struct net_device *dev, const u8 *mac, __be32 vni,462		      struct switchdev_notifier_vxlan_fdb_info *fdb_info)463{464	struct vxlan_dev *vxlan = netdev_priv(dev);465	u8 eth_addr[ETH_ALEN + 2] = { 0 };466	struct vxlan_rdst *rdst;467	struct vxlan_fdb *f;468	int rc = 0;469 470	if (is_multicast_ether_addr(mac) ||471	    is_zero_ether_addr(mac))472		return -EINVAL;473 474	ether_addr_copy(eth_addr, mac);475 476	rcu_read_lock();477 478	f = __vxlan_find_mac(vxlan, eth_addr, vni);479	if (!f) {480		rc = -ENOENT;481		goto out;482	}483 484	rdst = first_remote_rcu(f);485	vxlan_fdb_switchdev_notifier_info(vxlan, f, rdst, NULL, fdb_info);486 487out:488	rcu_read_unlock();489	return rc;490}491EXPORT_SYMBOL_GPL(vxlan_fdb_find_uc);492 493static int vxlan_fdb_notify_one(struct notifier_block *nb,494				const struct vxlan_dev *vxlan,495				const struct vxlan_fdb *f,496				const struct vxlan_rdst *rdst,497				struct netlink_ext_ack *extack)498{499	struct switchdev_notifier_vxlan_fdb_info fdb_info;500	int rc;501 502	vxlan_fdb_switchdev_notifier_info(vxlan, f, rdst, extack, &fdb_info);503	rc = nb->notifier_call(nb, SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE,504			       &fdb_info);505	return notifier_to_errno(rc);506}507 508int vxlan_fdb_replay(const struct net_device *dev, __be32 vni,509		     struct notifier_block *nb,510		     struct netlink_ext_ack *extack)511{512	struct vxlan_dev *vxlan;513	struct vxlan_rdst *rdst;514	struct vxlan_fdb *f;515	unsigned int h;516	int rc = 0;517 518	if (!netif_is_vxlan(dev))519		return -EINVAL;520	vxlan = netdev_priv(dev);521 522	for (h = 0; h < FDB_HASH_SIZE; ++h) {523		spin_lock_bh(&vxlan->hash_lock[h]);524		hlist_for_each_entry(f, &vxlan->fdb_head[h], hlist) {525			if (f->vni == vni) {526				list_for_each_entry(rdst, &f->remotes, list) {527					rc = vxlan_fdb_notify_one(nb, vxlan,528								  f, rdst,529								  extack);530					if (rc)531						goto unlock;532				}533			}534		}535		spin_unlock_bh(&vxlan->hash_lock[h]);536	}537	return 0;538 539unlock:540	spin_unlock_bh(&vxlan->hash_lock[h]);541	return rc;542}543EXPORT_SYMBOL_GPL(vxlan_fdb_replay);544 545void vxlan_fdb_clear_offload(const struct net_device *dev, __be32 vni)546{547	struct vxlan_dev *vxlan;548	struct vxlan_rdst *rdst;549	struct vxlan_fdb *f;550	unsigned int h;551 552	if (!netif_is_vxlan(dev))553		return;554	vxlan = netdev_priv(dev);555 556	for (h = 0; h < FDB_HASH_SIZE; ++h) {557		spin_lock_bh(&vxlan->hash_lock[h]);558		hlist_for_each_entry(f, &vxlan->fdb_head[h], hlist)559			if (f->vni == vni)560				list_for_each_entry(rdst, &f->remotes, list)561					rdst->offloaded = false;562		spin_unlock_bh(&vxlan->hash_lock[h]);563	}564 565}566EXPORT_SYMBOL_GPL(vxlan_fdb_clear_offload);567 568/* Replace destination of unicast mac */569static int vxlan_fdb_replace(struct vxlan_fdb *f,570			     union vxlan_addr *ip, __be16 port, __be32 vni,571			     __u32 ifindex, struct vxlan_rdst *oldrd)572{573	struct vxlan_rdst *rd;574 575	rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);576	if (rd)577		return 0;578 579	rd = list_first_entry_or_null(&f->remotes, struct vxlan_rdst, list);580	if (!rd)581		return 0;582 583	*oldrd = *rd;584	dst_cache_reset(&rd->dst_cache);585	rd->remote_ip = *ip;586	rd->remote_port = port;587	rd->remote_vni = vni;588	rd->remote_ifindex = ifindex;589	rd->offloaded = false;590	return 1;591}592 593/* Add/update destinations for multicast */594static int vxlan_fdb_append(struct vxlan_fdb *f,595			    union vxlan_addr *ip, __be16 port, __be32 vni,596			    __u32 ifindex, struct vxlan_rdst **rdp)597{598	struct vxlan_rdst *rd;599 600	rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);601	if (rd)602		return 0;603 604	rd = kmalloc(sizeof(*rd), GFP_ATOMIC);605	if (rd == NULL)606		return -ENOMEM;607 608	if (dst_cache_init(&rd->dst_cache, GFP_ATOMIC)) {609		kfree(rd);610		return -ENOMEM;611	}612 613	rd->remote_ip = *ip;614	rd->remote_port = port;615	rd->offloaded = false;616	rd->remote_vni = vni;617	rd->remote_ifindex = ifindex;618 619	list_add_tail_rcu(&rd->list, &f->remotes);620 621	*rdp = rd;622	return 1;623}624 625static bool vxlan_parse_gpe_proto(struct vxlanhdr *hdr, __be16 *protocol)626{627	struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)hdr;628 629	/* Need to have Next Protocol set for interfaces in GPE mode. */630	if (!gpe->np_applied)631		return false;632	/* "The initial version is 0. If a receiver does not support the633	 * version indicated it MUST drop the packet.634	 */635	if (gpe->version != 0)636		return false;637	/* "When the O bit is set to 1, the packet is an OAM packet and OAM638	 * processing MUST occur." However, we don't implement OAM639	 * processing, thus drop the packet.640	 */641	if (gpe->oam_flag)642		return false;643 644	*protocol = tun_p_to_eth_p(gpe->next_protocol);645	if (!*protocol)646		return false;647 648	return true;649}650 651static struct vxlanhdr *vxlan_gro_remcsum(struct sk_buff *skb,652					  unsigned int off,653					  struct vxlanhdr *vh, size_t hdrlen,654					  __be32 vni_field,655					  struct gro_remcsum *grc,656					  bool nopartial)657{658	size_t start, offset;659 660	if (skb->remcsum_offload)661		return vh;662 663	if (!NAPI_GRO_CB(skb)->csum_valid)664		return NULL;665 666	start = vxlan_rco_start(vni_field);667	offset = start + vxlan_rco_offset(vni_field);668 669	vh = skb_gro_remcsum_process(skb, (void *)vh, off, hdrlen,670				     start, offset, grc, nopartial);671 672	skb->remcsum_offload = 1;673 674	return vh;675}676 677static struct vxlanhdr *vxlan_gro_prepare_receive(struct sock *sk,678						  struct list_head *head,679						  struct sk_buff *skb,680						  struct gro_remcsum *grc)681{682	struct sk_buff *p;683	struct vxlanhdr *vh, *vh2;684	unsigned int hlen, off_vx;685	struct vxlan_sock *vs = rcu_dereference_sk_user_data(sk);686	__be32 flags;687 688	skb_gro_remcsum_init(grc);689 690	off_vx = skb_gro_offset(skb);691	hlen = off_vx + sizeof(*vh);692	vh = skb_gro_header(skb, hlen, off_vx);693	if (unlikely(!vh))694		return NULL;695 696	skb_gro_postpull_rcsum(skb, vh, sizeof(struct vxlanhdr));697 698	flags = vh->vx_flags;699 700	if ((flags & VXLAN_HF_RCO) && (vs->flags & VXLAN_F_REMCSUM_RX)) {701		vh = vxlan_gro_remcsum(skb, off_vx, vh, sizeof(struct vxlanhdr),702				       vh->vx_vni, grc,703				       !!(vs->flags &704					  VXLAN_F_REMCSUM_NOPARTIAL));705 706		if (!vh)707			return NULL;708	}709 710	skb_gro_pull(skb, sizeof(struct vxlanhdr)); /* pull vxlan header */711 712	list_for_each_entry(p, head, list) {713		if (!NAPI_GRO_CB(p)->same_flow)714			continue;715 716		vh2 = (struct vxlanhdr *)(p->data + off_vx);717		if (vh->vx_flags != vh2->vx_flags ||718		    vh->vx_vni != vh2->vx_vni) {719			NAPI_GRO_CB(p)->same_flow = 0;720			continue;721		}722	}723 724	return vh;725}726 727static struct sk_buff *vxlan_gro_receive(struct sock *sk,728					 struct list_head *head,729					 struct sk_buff *skb)730{731	struct sk_buff *pp = NULL;732	struct gro_remcsum grc;733	int flush = 1;734 735	if (vxlan_gro_prepare_receive(sk, head, skb, &grc)) {736		pp = call_gro_receive(eth_gro_receive, head, skb);737		flush = 0;738	}739	skb_gro_flush_final_remcsum(skb, pp, flush, &grc);740	return pp;741}742 743static struct sk_buff *vxlan_gpe_gro_receive(struct sock *sk,744					     struct list_head *head,745					     struct sk_buff *skb)746{747	const struct packet_offload *ptype;748	struct sk_buff *pp = NULL;749	struct gro_remcsum grc;750	struct vxlanhdr *vh;751	__be16 protocol;752	int flush = 1;753 754	vh = vxlan_gro_prepare_receive(sk, head, skb, &grc);755	if (vh) {756		if (!vxlan_parse_gpe_proto(vh, &protocol))757			goto out;758		ptype = gro_find_receive_by_type(protocol);759		if (!ptype)760			goto out;761		pp = call_gro_receive(ptype->callbacks.gro_receive, head, skb);762		flush = 0;763	}764out:765	skb_gro_flush_final_remcsum(skb, pp, flush, &grc);766	return pp;767}768 769static int vxlan_gro_complete(struct sock *sk, struct sk_buff *skb, int nhoff)770{771	/* Sets 'skb->inner_mac_header' since we are always called with772	 * 'skb->encapsulation' set.773	 */774	return eth_gro_complete(skb, nhoff + sizeof(struct vxlanhdr));775}776 777static int vxlan_gpe_gro_complete(struct sock *sk, struct sk_buff *skb, int nhoff)778{779	struct vxlanhdr *vh = (struct vxlanhdr *)(skb->data + nhoff);780	const struct packet_offload *ptype;781	int err = -ENOSYS;782	__be16 protocol;783 784	if (!vxlan_parse_gpe_proto(vh, &protocol))785		return err;786	ptype = gro_find_complete_by_type(protocol);787	if (ptype)788		err = ptype->callbacks.gro_complete(skb, nhoff + sizeof(struct vxlanhdr));789	return err;790}791 792static struct vxlan_fdb *vxlan_fdb_alloc(struct vxlan_dev *vxlan, const u8 *mac,793					 __u16 state, __be32 src_vni,794					 __u16 ndm_flags)795{796	struct vxlan_fdb *f;797 798	f = kmalloc(sizeof(*f), GFP_ATOMIC);799	if (!f)800		return NULL;801	f->state = state;802	f->flags = ndm_flags;803	f->updated = f->used = jiffies;804	f->vni = src_vni;805	f->nh = NULL;806	RCU_INIT_POINTER(f->vdev, vxlan);807	INIT_LIST_HEAD(&f->nh_list);808	INIT_LIST_HEAD(&f->remotes);809	memcpy(f->eth_addr, mac, ETH_ALEN);810 811	return f;812}813 814static void vxlan_fdb_insert(struct vxlan_dev *vxlan, const u8 *mac,815			     __be32 src_vni, struct vxlan_fdb *f)816{817	++vxlan->addrcnt;818	hlist_add_head_rcu(&f->hlist,819			   vxlan_fdb_head(vxlan, mac, src_vni));820}821 822static int vxlan_fdb_nh_update(struct vxlan_dev *vxlan, struct vxlan_fdb *fdb,823			       u32 nhid, struct netlink_ext_ack *extack)824{825	struct nexthop *old_nh = rtnl_dereference(fdb->nh);826	struct nexthop *nh;827	int err = -EINVAL;828 829	if (old_nh && old_nh->id == nhid)830		return 0;831 832	nh = nexthop_find_by_id(vxlan->net, nhid);833	if (!nh) {834		NL_SET_ERR_MSG(extack, "Nexthop id does not exist");835		goto err_inval;836	}837 838	if (!nexthop_get(nh)) {839		NL_SET_ERR_MSG(extack, "Nexthop has been deleted");840		nh = NULL;841		goto err_inval;842	}843	if (!nexthop_is_fdb(nh)) {844		NL_SET_ERR_MSG(extack, "Nexthop is not a fdb nexthop");845		goto err_inval;846	}847 848	if (!nexthop_is_multipath(nh)) {849		NL_SET_ERR_MSG(extack, "Nexthop is not a multipath group");850		goto err_inval;851	}852 853	/* check nexthop group family */854	switch (vxlan->default_dst.remote_ip.sa.sa_family) {855	case AF_INET:856		if (!nexthop_has_v4(nh)) {857			err = -EAFNOSUPPORT;858			NL_SET_ERR_MSG(extack, "Nexthop group family not supported");859			goto err_inval;860		}861		break;862	case AF_INET6:863		if (nexthop_has_v4(nh)) {864			err = -EAFNOSUPPORT;865			NL_SET_ERR_MSG(extack, "Nexthop group family not supported");866			goto err_inval;867		}868	}869 870	if (old_nh) {871		list_del_rcu(&fdb->nh_list);872		nexthop_put(old_nh);873	}874	rcu_assign_pointer(fdb->nh, nh);875	list_add_tail_rcu(&fdb->nh_list, &nh->fdb_list);876	return 1;877 878err_inval:879	if (nh)880		nexthop_put(nh);881	return err;882}883 884int vxlan_fdb_create(struct vxlan_dev *vxlan,885		     const u8 *mac, union vxlan_addr *ip,886		     __u16 state, __be16 port, __be32 src_vni,887		     __be32 vni, __u32 ifindex, __u16 ndm_flags,888		     u32 nhid, struct vxlan_fdb **fdb,889		     struct netlink_ext_ack *extack)890{891	struct vxlan_rdst *rd = NULL;892	struct vxlan_fdb *f;893	int rc;894 895	if (vxlan->cfg.addrmax &&896	    vxlan->addrcnt >= vxlan->cfg.addrmax)897		return -ENOSPC;898 899	netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);900	f = vxlan_fdb_alloc(vxlan, mac, state, src_vni, ndm_flags);901	if (!f)902		return -ENOMEM;903 904	if (nhid)905		rc = vxlan_fdb_nh_update(vxlan, f, nhid, extack);906	else907		rc = vxlan_fdb_append(f, ip, port, vni, ifindex, &rd);908	if (rc < 0)909		goto errout;910 911	*fdb = f;912 913	return 0;914 915errout:916	kfree(f);917	return rc;918}919 920static void __vxlan_fdb_free(struct vxlan_fdb *f)921{922	struct vxlan_rdst *rd, *nd;923	struct nexthop *nh;924 925	nh = rcu_dereference_raw(f->nh);926	if (nh) {927		rcu_assign_pointer(f->nh, NULL);928		rcu_assign_pointer(f->vdev, NULL);929		nexthop_put(nh);930	}931 932	list_for_each_entry_safe(rd, nd, &f->remotes, list) {933		dst_cache_destroy(&rd->dst_cache);934		kfree(rd);935	}936	kfree(f);937}938 939static void vxlan_fdb_free(struct rcu_head *head)940{941	struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);942 943	__vxlan_fdb_free(f);944}945 946static void vxlan_fdb_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f,947			      bool do_notify, bool swdev_notify)948{949	struct vxlan_rdst *rd;950 951	netdev_dbg(vxlan->dev, "delete %pM\n", f->eth_addr);952 953	--vxlan->addrcnt;954	if (do_notify) {955		if (rcu_access_pointer(f->nh))956			vxlan_fdb_notify(vxlan, f, NULL, RTM_DELNEIGH,957					 swdev_notify, NULL);958		else959			list_for_each_entry(rd, &f->remotes, list)960				vxlan_fdb_notify(vxlan, f, rd, RTM_DELNEIGH,961						 swdev_notify, NULL);962	}963 964	hlist_del_rcu(&f->hlist);965	list_del_rcu(&f->nh_list);966	call_rcu(&f->rcu, vxlan_fdb_free);967}968 969static void vxlan_dst_free(struct rcu_head *head)970{971	struct vxlan_rdst *rd = container_of(head, struct vxlan_rdst, rcu);972 973	dst_cache_destroy(&rd->dst_cache);974	kfree(rd);975}976 977static int vxlan_fdb_update_existing(struct vxlan_dev *vxlan,978				     union vxlan_addr *ip,979				     __u16 state, __u16 flags,980				     __be16 port, __be32 vni,981				     __u32 ifindex, __u16 ndm_flags,982				     struct vxlan_fdb *f, u32 nhid,983				     bool swdev_notify,984				     struct netlink_ext_ack *extack)985{986	__u16 fdb_flags = (ndm_flags & ~NTF_USE);987	struct vxlan_rdst *rd = NULL;988	struct vxlan_rdst oldrd;989	int notify = 0;990	int rc = 0;991	int err;992 993	if (nhid && !rcu_access_pointer(f->nh)) {994		NL_SET_ERR_MSG(extack,995			       "Cannot replace an existing non nexthop fdb with a nexthop");996		return -EOPNOTSUPP;997	}998 999	if (nhid && (flags & NLM_F_APPEND)) {1000		NL_SET_ERR_MSG(extack,1001			       "Cannot append to a nexthop fdb");1002		return -EOPNOTSUPP;1003	}1004 1005	/* Do not allow an externally learned entry to take over an entry added1006	 * by the user.1007	 */1008	if (!(fdb_flags & NTF_EXT_LEARNED) ||1009	    !(f->flags & NTF_VXLAN_ADDED_BY_USER)) {1010		if (f->state != state) {1011			f->state = state;1012			f->updated = jiffies;1013			notify = 1;1014		}1015		if (f->flags != fdb_flags) {1016			f->flags = fdb_flags;1017			f->updated = jiffies;1018			notify = 1;1019		}1020	}1021 1022	if ((flags & NLM_F_REPLACE)) {1023		/* Only change unicasts */1024		if (!(is_multicast_ether_addr(f->eth_addr) ||1025		      is_zero_ether_addr(f->eth_addr))) {1026			if (nhid) {1027				rc = vxlan_fdb_nh_update(vxlan, f, nhid, extack);1028				if (rc < 0)1029					return rc;1030			} else {1031				rc = vxlan_fdb_replace(f, ip, port, vni,1032						       ifindex, &oldrd);1033			}1034			notify |= rc;1035		} else {1036			NL_SET_ERR_MSG(extack, "Cannot replace non-unicast fdb entries");1037			return -EOPNOTSUPP;1038		}1039	}1040	if ((flags & NLM_F_APPEND) &&1041	    (is_multicast_ether_addr(f->eth_addr) ||1042	     is_zero_ether_addr(f->eth_addr))) {1043		rc = vxlan_fdb_append(f, ip, port, vni, ifindex, &rd);1044 1045		if (rc < 0)1046			return rc;1047		notify |= rc;1048	}1049 1050	if (ndm_flags & NTF_USE)1051		f->used = jiffies;1052 1053	if (notify) {1054		if (rd == NULL)1055			rd = first_remote_rtnl(f);1056 1057		err = vxlan_fdb_notify(vxlan, f, rd, RTM_NEWNEIGH,1058				       swdev_notify, extack);1059		if (err)1060			goto err_notify;1061	}1062 1063	return 0;1064 1065err_notify:1066	if (nhid)1067		return err;1068	if ((flags & NLM_F_REPLACE) && rc)1069		*rd = oldrd;1070	else if ((flags & NLM_F_APPEND) && rc) {1071		list_del_rcu(&rd->list);1072		call_rcu(&rd->rcu, vxlan_dst_free);1073	}1074	return err;1075}1076 1077static int vxlan_fdb_update_create(struct vxlan_dev *vxlan,1078				   const u8 *mac, union vxlan_addr *ip,1079				   __u16 state, __u16 flags,1080				   __be16 port, __be32 src_vni, __be32 vni,1081				   __u32 ifindex, __u16 ndm_flags, u32 nhid,1082				   bool swdev_notify,1083				   struct netlink_ext_ack *extack)1084{1085	__u16 fdb_flags = (ndm_flags & ~NTF_USE);1086	struct vxlan_fdb *f;1087	int rc;1088 1089	/* Disallow replace to add a multicast entry */1090	if ((flags & NLM_F_REPLACE) &&1091	    (is_multicast_ether_addr(mac) || is_zero_ether_addr(mac)))1092		return -EOPNOTSUPP;1093 1094	netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);1095	rc = vxlan_fdb_create(vxlan, mac, ip, state, port, src_vni,1096			      vni, ifindex, fdb_flags, nhid, &f, extack);1097	if (rc < 0)1098		return rc;1099 1100	vxlan_fdb_insert(vxlan, mac, src_vni, f);1101	rc = vxlan_fdb_notify(vxlan, f, first_remote_rtnl(f), RTM_NEWNEIGH,1102			      swdev_notify, extack);1103	if (rc)1104		goto err_notify;1105 1106	return 0;1107 1108err_notify:1109	vxlan_fdb_destroy(vxlan, f, false, false);1110	return rc;1111}1112 1113/* Add new entry to forwarding table -- assumes lock held */1114int vxlan_fdb_update(struct vxlan_dev *vxlan,1115		     const u8 *mac, union vxlan_addr *ip,1116		     __u16 state, __u16 flags,1117		     __be16 port, __be32 src_vni, __be32 vni,1118		     __u32 ifindex, __u16 ndm_flags, u32 nhid,1119		     bool swdev_notify,1120		     struct netlink_ext_ack *extack)1121{1122	struct vxlan_fdb *f;1123 1124	f = __vxlan_find_mac(vxlan, mac, src_vni);1125	if (f) {1126		if (flags & NLM_F_EXCL) {1127			netdev_dbg(vxlan->dev,1128				   "lost race to create %pM\n", mac);1129			return -EEXIST;1130		}1131 1132		return vxlan_fdb_update_existing(vxlan, ip, state, flags, port,1133						 vni, ifindex, ndm_flags, f,1134						 nhid, swdev_notify, extack);1135	} else {1136		if (!(flags & NLM_F_CREATE))1137			return -ENOENT;1138 1139		return vxlan_fdb_update_create(vxlan, mac, ip, state, flags,1140					       port, src_vni, vni, ifindex,1141					       ndm_flags, nhid, swdev_notify,1142					       extack);1143	}1144}1145 1146static void vxlan_fdb_dst_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f,1147				  struct vxlan_rdst *rd, bool swdev_notify)1148{1149	list_del_rcu(&rd->list);1150	vxlan_fdb_notify(vxlan, f, rd, RTM_DELNEIGH, swdev_notify, NULL);1151	call_rcu(&rd->rcu, vxlan_dst_free);1152}1153 1154static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,1155			   union vxlan_addr *ip, __be16 *port, __be32 *src_vni,1156			   __be32 *vni, u32 *ifindex, u32 *nhid,1157			   struct netlink_ext_ack *extack)1158{1159	struct net *net = dev_net(vxlan->dev);1160	int err;1161 1162	if (tb[NDA_NH_ID] &&1163	    (tb[NDA_DST] || tb[NDA_VNI] || tb[NDA_IFINDEX] || tb[NDA_PORT])) {1164		NL_SET_ERR_MSG(extack, "DST, VNI, ifindex and port are mutually exclusive with NH_ID");1165		return -EINVAL;1166	}1167 1168	if (tb[NDA_DST]) {1169		err = vxlan_nla_get_addr(ip, tb[NDA_DST]);1170		if (err) {1171			NL_SET_ERR_MSG(extack, "Unsupported address family");1172			return err;1173		}1174	} else {1175		union vxlan_addr *remote = &vxlan->default_dst.remote_ip;1176 1177		if (remote->sa.sa_family == AF_INET) {1178			ip->sin.sin_addr.s_addr = htonl(INADDR_ANY);1179			ip->sa.sa_family = AF_INET;1180#if IS_ENABLED(CONFIG_IPV6)1181		} else {1182			ip->sin6.sin6_addr = in6addr_any;1183			ip->sa.sa_family = AF_INET6;1184#endif1185		}1186	}1187 1188	if (tb[NDA_PORT]) {1189		if (nla_len(tb[NDA_PORT]) != sizeof(__be16)) {1190			NL_SET_ERR_MSG(extack, "Invalid vxlan port");1191			return -EINVAL;1192		}1193		*port = nla_get_be16(tb[NDA_PORT]);1194	} else {1195		*port = vxlan->cfg.dst_port;1196	}1197 1198	if (tb[NDA_VNI]) {1199		if (nla_len(tb[NDA_VNI]) != sizeof(u32)) {1200			NL_SET_ERR_MSG(extack, "Invalid vni");1201			return -EINVAL;1202		}1203		*vni = cpu_to_be32(nla_get_u32(tb[NDA_VNI]));1204	} else {1205		*vni = vxlan->default_dst.remote_vni;1206	}1207 1208	if (tb[NDA_SRC_VNI]) {1209		if (nla_len(tb[NDA_SRC_VNI]) != sizeof(u32)) {1210			NL_SET_ERR_MSG(extack, "Invalid src vni");1211			return -EINVAL;1212		}1213		*src_vni = cpu_to_be32(nla_get_u32(tb[NDA_SRC_VNI]));1214	} else {1215		*src_vni = vxlan->default_dst.remote_vni;1216	}1217 1218	if (tb[NDA_IFINDEX]) {1219		struct net_device *tdev;1220 1221		if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32)) {1222			NL_SET_ERR_MSG(extack, "Invalid ifindex");1223			return -EINVAL;1224		}1225		*ifindex = nla_get_u32(tb[NDA_IFINDEX]);1226		tdev = __dev_get_by_index(net, *ifindex);1227		if (!tdev) {1228			NL_SET_ERR_MSG(extack, "Device not found");1229			return -EADDRNOTAVAIL;1230		}1231	} else {1232		*ifindex = 0;1233	}1234 1235	if (tb[NDA_NH_ID])1236		*nhid = nla_get_u32(tb[NDA_NH_ID]);1237	else1238		*nhid = 0;1239 1240	return 0;1241}1242 1243/* Add static entry (via netlink) */1244static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],1245			 struct net_device *dev,1246			 const unsigned char *addr, u16 vid, u16 flags,1247			 struct netlink_ext_ack *extack)1248{1249	struct vxlan_dev *vxlan = netdev_priv(dev);1250	/* struct net *net = dev_net(vxlan->dev); */1251	union vxlan_addr ip;1252	__be16 port;1253	__be32 src_vni, vni;1254	u32 ifindex, nhid;1255	u32 hash_index;1256	int err;1257 1258	if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_REACHABLE))) {1259		pr_info("RTM_NEWNEIGH with invalid state %#x\n",1260			ndm->ndm_state);1261		return -EINVAL;1262	}1263 1264	if (!tb || (!tb[NDA_DST] && !tb[NDA_NH_ID]))1265		return -EINVAL;1266 1267	err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &src_vni, &vni, &ifindex,1268			      &nhid, extack);1269	if (err)1270		return err;1271 1272	if (vxlan->default_dst.remote_ip.sa.sa_family != ip.sa.sa_family)1273		return -EAFNOSUPPORT;1274 1275	hash_index = fdb_head_index(vxlan, addr, src_vni);1276	spin_lock_bh(&vxlan->hash_lock[hash_index]);1277	err = vxlan_fdb_update(vxlan, addr, &ip, ndm->ndm_state, flags,1278			       port, src_vni, vni, ifindex,1279			       ndm->ndm_flags | NTF_VXLAN_ADDED_BY_USER,1280			       nhid, true, extack);1281	spin_unlock_bh(&vxlan->hash_lock[hash_index]);1282 1283	return err;1284}1285 1286int __vxlan_fdb_delete(struct vxlan_dev *vxlan,1287		       const unsigned char *addr, union vxlan_addr ip,1288		       __be16 port, __be32 src_vni, __be32 vni,1289		       u32 ifindex, bool swdev_notify)1290{1291	struct vxlan_rdst *rd = NULL;1292	struct vxlan_fdb *f;1293	int err = -ENOENT;1294 1295	f = vxlan_find_mac(vxlan, addr, src_vni);1296	if (!f)1297		return err;1298 1299	if (!vxlan_addr_any(&ip)) {1300		rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);1301		if (!rd)1302			goto out;1303	}1304 1305	/* remove a destination if it's not the only one on the list,1306	 * otherwise destroy the fdb entry1307	 */1308	if (rd && !list_is_singular(&f->remotes)) {1309		vxlan_fdb_dst_destroy(vxlan, f, rd, swdev_notify);1310		goto out;1311	}1312 1313	vxlan_fdb_destroy(vxlan, f, true, swdev_notify);1314 1315out:1316	return 0;1317}1318 1319/* Delete entry (via netlink) */1320static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],1321			    struct net_device *dev,1322			    const unsigned char *addr, u16 vid,1323			    struct netlink_ext_ack *extack)1324{1325	struct vxlan_dev *vxlan = netdev_priv(dev);1326	union vxlan_addr ip;1327	__be32 src_vni, vni;1328	u32 ifindex, nhid;1329	u32 hash_index;1330	__be16 port;1331	int err;1332 1333	err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &src_vni, &vni, &ifindex,1334			      &nhid, extack);1335	if (err)1336		return err;1337 1338	hash_index = fdb_head_index(vxlan, addr, src_vni);1339	spin_lock_bh(&vxlan->hash_lock[hash_index]);1340	err = __vxlan_fdb_delete(vxlan, addr, ip, port, src_vni, vni, ifindex,1341				 true);1342	spin_unlock_bh(&vxlan->hash_lock[hash_index]);1343 1344	return err;1345}1346 1347/* Dump forwarding table */1348static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,1349			  struct net_device *dev,1350			  struct net_device *filter_dev, int *idx)1351{1352	struct vxlan_dev *vxlan = netdev_priv(dev);1353	unsigned int h;1354	int err = 0;1355 1356	for (h = 0; h < FDB_HASH_SIZE; ++h) {1357		struct vxlan_fdb *f;1358 1359		rcu_read_lock();1360		hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {1361			struct vxlan_rdst *rd;1362 1363			if (rcu_access_pointer(f->nh)) {1364				if (*idx < cb->args[2])1365					goto skip_nh;1366				err = vxlan_fdb_info(skb, vxlan, f,1367						     NETLINK_CB(cb->skb).portid,1368						     cb->nlh->nlmsg_seq,1369						     RTM_NEWNEIGH,1370						     NLM_F_MULTI, NULL);1371				if (err < 0) {1372					rcu_read_unlock();1373					goto out;1374				}1375skip_nh:1376				*idx += 1;1377				continue;1378			}1379 1380			list_for_each_entry_rcu(rd, &f->remotes, list) {1381				if (*idx < cb->args[2])1382					goto skip;1383 1384				err = vxlan_fdb_info(skb, vxlan, f,1385						     NETLINK_CB(cb->skb).portid,1386						     cb->nlh->nlmsg_seq,1387						     RTM_NEWNEIGH,1388						     NLM_F_MULTI, rd);1389				if (err < 0) {1390					rcu_read_unlock();1391					goto out;1392				}1393skip:1394				*idx += 1;1395			}1396		}1397		rcu_read_unlock();1398	}1399out:1400	return err;1401}1402 1403static int vxlan_fdb_get(struct sk_buff *skb,1404			 struct nlattr *tb[],1405			 struct net_device *dev,1406			 const unsigned char *addr,1407			 u16 vid, u32 portid, u32 seq,1408			 struct netlink_ext_ack *extack)1409{1410	struct vxlan_dev *vxlan = netdev_priv(dev);1411	struct vxlan_fdb *f;1412	__be32 vni;1413	int err;1414 1415	if (tb[NDA_VNI])1416		vni = cpu_to_be32(nla_get_u32(tb[NDA_VNI]));1417	else1418		vni = vxlan->default_dst.remote_vni;1419 1420	rcu_read_lock();1421 1422	f = __vxlan_find_mac(vxlan, addr, vni);1423	if (!f) {1424		NL_SET_ERR_MSG(extack, "Fdb entry not found");1425		err = -ENOENT;1426		goto errout;1427	}1428 1429	err = vxlan_fdb_info(skb, vxlan, f, portid, seq,1430			     RTM_NEWNEIGH, 0, first_remote_rcu(f));1431errout:1432	rcu_read_unlock();1433	return err;1434}1435 1436/* Watch incoming packets to learn mapping between Ethernet address1437 * and Tunnel endpoint.1438 * Return true if packet is bogus and should be dropped.1439 */1440static bool vxlan_snoop(struct net_device *dev,1441			union vxlan_addr *src_ip, const u8 *src_mac,1442			u32 src_ifindex, __be32 vni)1443{1444	struct vxlan_dev *vxlan = netdev_priv(dev);1445	struct vxlan_fdb *f;1446	u32 ifindex = 0;1447 1448	/* Ignore packets from invalid src-address */1449	if (!is_valid_ether_addr(src_mac))1450		return true;1451 1452#if IS_ENABLED(CONFIG_IPV6)1453	if (src_ip->sa.sa_family == AF_INET6 &&1454	    (ipv6_addr_type(&src_ip->sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL))1455		ifindex = src_ifindex;1456#endif1457 1458	f = vxlan_find_mac(vxlan, src_mac, vni);1459	if (likely(f)) {1460		struct vxlan_rdst *rdst = first_remote_rcu(f);1461 1462		if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip) &&1463			   rdst->remote_ifindex == ifindex))1464			return false;1465 1466		/* Don't migrate static entries, drop packets */1467		if (f->state & (NUD_PERMANENT | NUD_NOARP))1468			return true;1469 1470		/* Don't override an fdb with nexthop with a learnt entry */1471		if (rcu_access_pointer(f->nh))1472			return true;1473 1474		if (net_ratelimit())1475			netdev_info(dev,1476				    "%pM migrated from %pIS to %pIS\n",1477				    src_mac, &rdst->remote_ip.sa, &src_ip->sa);1478 1479		rdst->remote_ip = *src_ip;1480		f->updated = jiffies;1481		vxlan_fdb_notify(vxlan, f, rdst, RTM_NEWNEIGH, true, NULL);1482	} else {1483		u32 hash_index = fdb_head_index(vxlan, src_mac, vni);1484 1485		/* learned new entry */1486		spin_lock(&vxlan->hash_lock[hash_index]);1487 1488		/* close off race between vxlan_flush and incoming packets */1489		if (netif_running(dev))1490			vxlan_fdb_update(vxlan, src_mac, src_ip,1491					 NUD_REACHABLE,1492					 NLM_F_EXCL|NLM_F_CREATE,1493					 vxlan->cfg.dst_port,1494					 vni,1495					 vxlan->default_dst.remote_vni,1496					 ifindex, NTF_SELF, 0, true, NULL);1497		spin_unlock(&vxlan->hash_lock[hash_index]);1498	}1499 1500	return false;1501}1502 1503static bool __vxlan_sock_release_prep(struct vxlan_sock *vs)1504{1505	struct vxlan_net *vn;1506 1507	if (!vs)1508		return false;1509	if (!refcount_dec_and_test(&vs->refcnt))1510		return false;1511 1512	vn = net_generic(sock_net(vs->sock->sk), vxlan_net_id);1513	spin_lock(&vn->sock_lock);1514	hlist_del_rcu(&vs->hlist);1515	udp_tunnel_notify_del_rx_port(vs->sock,1516				      (vs->flags & VXLAN_F_GPE) ?1517				      UDP_TUNNEL_TYPE_VXLAN_GPE :1518				      UDP_TUNNEL_TYPE_VXLAN);1519	spin_unlock(&vn->sock_lock);1520 1521	return true;1522}1523 1524static void vxlan_sock_release(struct vxlan_dev *vxlan)1525{1526	struct vxlan_sock *sock4 = rtnl_dereference(vxlan->vn4_sock);1527#if IS_ENABLED(CONFIG_IPV6)1528	struct vxlan_sock *sock6 = rtnl_dereference(vxlan->vn6_sock);1529 1530	RCU_INIT_POINTER(vxlan->vn6_sock, NULL);1531#endif1532 1533	RCU_INIT_POINTER(vxlan->vn4_sock, NULL);1534	synchronize_net();1535 1536	if (vxlan->cfg.flags & VXLAN_F_VNIFILTER)1537		vxlan_vs_del_vnigrp(vxlan);1538	else1539		vxlan_vs_del_dev(vxlan);1540 1541	if (__vxlan_sock_release_prep(sock4)) {1542		udp_tunnel_sock_release(sock4->sock);1543		kfree(sock4);1544	}1545 1546#if IS_ENABLED(CONFIG_IPV6)1547	if (__vxlan_sock_release_prep(sock6)) {1548		udp_tunnel_sock_release(sock6->sock);1549		kfree(sock6);1550	}1551#endif1552}1553 1554static bool vxlan_remcsum(struct vxlanhdr *unparsed,1555			  struct sk_buff *skb, u32 vxflags)1556{1557	size_t start, offset;1558 1559	if (!(unparsed->vx_flags & VXLAN_HF_RCO) || skb->remcsum_offload)1560		goto out;1561 1562	start = vxlan_rco_start(unparsed->vx_vni);1563	offset = start + vxlan_rco_offset(unparsed->vx_vni);1564 1565	if (!pskb_may_pull(skb, offset + sizeof(u16)))1566		return false;1567 1568	skb_remcsum_process(skb, (void *)(vxlan_hdr(skb) + 1), start, offset,1569			    !!(vxflags & VXLAN_F_REMCSUM_NOPARTIAL));1570out:1571	unparsed->vx_flags &= ~VXLAN_HF_RCO;1572	unparsed->vx_vni &= VXLAN_VNI_MASK;1573	return true;1574}1575 1576static void vxlan_parse_gbp_hdr(struct vxlanhdr *unparsed,1577				struct sk_buff *skb, u32 vxflags,1578				struct vxlan_metadata *md)1579{1580	struct vxlanhdr_gbp *gbp = (struct vxlanhdr_gbp *)unparsed;1581	struct metadata_dst *tun_dst;1582 1583	if (!(unparsed->vx_flags & VXLAN_HF_GBP))1584		goto out;1585 1586	md->gbp = ntohs(gbp->policy_id);1587 1588	tun_dst = (struct metadata_dst *)skb_dst(skb);1589	if (tun_dst) {1590		__set_bit(IP_TUNNEL_VXLAN_OPT_BIT,1591			  tun_dst->u.tun_info.key.tun_flags);1592		tun_dst->u.tun_info.options_len = sizeof(*md);1593	}1594	if (gbp->dont_learn)1595		md->gbp |= VXLAN_GBP_DONT_LEARN;1596 1597	if (gbp->policy_applied)1598		md->gbp |= VXLAN_GBP_POLICY_APPLIED;1599 1600	/* In flow-based mode, GBP is carried in dst_metadata */1601	if (!(vxflags & VXLAN_F_COLLECT_METADATA))1602		skb->mark = md->gbp;1603out:1604	unparsed->vx_flags &= ~VXLAN_GBP_USED_BITS;1605}1606 1607static bool vxlan_set_mac(struct vxlan_dev *vxlan,1608			  struct vxlan_sock *vs,1609			  struct sk_buff *skb, __be32 vni)1610{1611	union vxlan_addr saddr;1612	u32 ifindex = skb->dev->ifindex;1613 1614	skb_reset_mac_header(skb);1615	skb->protocol = eth_type_trans(skb, vxlan->dev);1616	skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);1617 1618	/* Ignore packet loops (and multicast echo) */1619	if (ether_addr_equal(eth_hdr(skb)->h_source, vxlan->dev->dev_addr))1620		return false;1621 1622	/* Get address from the outer IP header */1623	if (vxlan_get_sk_family(vs) == AF_INET) {1624		saddr.sin.sin_addr.s_addr = ip_hdr(skb)->saddr;1625		saddr.sa.sa_family = AF_INET;1626#if IS_ENABLED(CONFIG_IPV6)1627	} else {1628		saddr.sin6.sin6_addr = ipv6_hdr(skb)->saddr;1629		saddr.sa.sa_family = AF_INET6;1630#endif1631	}1632 1633	if ((vxlan->cfg.flags & VXLAN_F_LEARN) &&1634	    vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source, ifindex, vni))1635		return false;1636 1637	return true;1638}1639 1640static bool vxlan_ecn_decapsulate(struct vxlan_sock *vs, void *oiph,1641				  struct sk_buff *skb)1642{1643	int err = 0;1644 1645	if (vxlan_get_sk_family(vs) == AF_INET)1646		err = IP_ECN_decapsulate(oiph, skb);1647#if IS_ENABLED(CONFIG_IPV6)1648	else1649		err = IP6_ECN_decapsulate(oiph, skb);1650#endif1651 1652	if (unlikely(err) && log_ecn_error) {1653		if (vxlan_get_sk_family(vs) == AF_INET)1654			net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",1655					     &((struct iphdr *)oiph)->saddr,1656					     ((struct iphdr *)oiph)->tos);1657		else1658			net_info_ratelimited("non-ECT from %pI6\n",1659					     &((struct ipv6hdr *)oiph)->saddr);1660	}1661	return err <= 1;1662}1663 1664/* Callback from net/ipv4/udp.c to receive packets */1665static int vxlan_rcv(struct sock *sk, struct sk_buff *skb)1666{1667	struct vxlan_vni_node *vninode = NULL;1668	struct vxlan_dev *vxlan;1669	struct vxlan_sock *vs;1670	struct vxlanhdr unparsed;1671	struct vxlan_metadata _md;1672	struct vxlan_metadata *md = &_md;1673	__be16 protocol = htons(ETH_P_TEB);1674	bool raw_proto = false;1675	void *oiph;1676	__be32 vni = 0;1677	int nh;1678 1679	/* Need UDP and VXLAN header to be present */1680	if (!pskb_may_pull(skb, VXLAN_HLEN))1681		goto drop;1682 1683	unparsed = *vxlan_hdr(skb);1684	/* VNI flag always required to be set */1685	if (!(unparsed.vx_flags & VXLAN_HF_VNI)) {1686		netdev_dbg(skb->dev, "invalid vxlan flags=%#x vni=%#x\n",1687			   ntohl(vxlan_hdr(skb)->vx_flags),1688			   ntohl(vxlan_hdr(skb)->vx_vni));1689		/* Return non vxlan pkt */1690		goto drop;1691	}1692	unparsed.vx_flags &= ~VXLAN_HF_VNI;1693	unparsed.vx_vni &= ~VXLAN_VNI_MASK;1694 1695	vs = rcu_dereference_sk_user_data(sk);1696	if (!vs)1697		goto drop;1698 1699	vni = vxlan_vni(vxlan_hdr(skb)->vx_vni);1700 1701	vxlan = vxlan_vs_find_vni(vs, skb->dev->ifindex, vni, &vninode);1702	if (!vxlan)1703		goto drop;1704 1705	/* For backwards compatibility, only allow reserved fields to be1706	 * used by VXLAN extensions if explicitly requested.1707	 */1708	if (vs->flags & VXLAN_F_GPE) {1709		if (!vxlan_parse_gpe_proto(&unparsed, &protocol))1710			goto drop;1711		unparsed.vx_flags &= ~VXLAN_GPE_USED_BITS;1712		raw_proto = true;1713	}1714 1715	if (__iptunnel_pull_header(skb, VXLAN_HLEN, protocol, raw_proto,1716				   !net_eq(vxlan->net, dev_net(vxlan->dev))))1717		goto drop;1718 1719	if (vs->flags & VXLAN_F_REMCSUM_RX)1720		if (unlikely(!vxlan_remcsum(&unparsed, skb, vs->flags)))1721			goto drop;1722 1723	if (vxlan_collect_metadata(vs)) {1724		IP_TUNNEL_DECLARE_FLAGS(flags) = { };1725		struct metadata_dst *tun_dst;1726 1727		__set_bit(IP_TUNNEL_KEY_BIT, flags);1728		tun_dst = udp_tun_rx_dst(skb, vxlan_get_sk_family(vs), flags,1729					 key32_to_tunnel_id(vni), sizeof(*md));1730 1731		if (!tun_dst)1732			goto drop;1733 1734		md = ip_tunnel_info_opts(&tun_dst->u.tun_info);1735 1736		skb_dst_set(skb, (struct dst_entry *)tun_dst);1737	} else {1738		memset(md, 0, sizeof(*md));1739	}1740 1741	if (vs->flags & VXLAN_F_GBP)1742		vxlan_parse_gbp_hdr(&unparsed, skb, vs->flags, md);1743	/* Note that GBP and GPE can never be active together. This is1744	 * ensured in vxlan_dev_configure.1745	 */1746 1747	if (unparsed.vx_flags || unparsed.vx_vni) {1748		/* If there are any unprocessed flags remaining treat1749		 * this as a malformed packet. This behavior diverges from1750		 * VXLAN RFC (RFC7348) which stipulates that bits in reserved1751		 * in reserved fields are to be ignored. The approach here1752		 * maintains compatibility with previous stack code, and also1753		 * is more robust and provides a little more security in1754		 * adding extensions to VXLAN.1755		 */1756		goto drop;1757	}1758 1759	if (!raw_proto) {1760		if (!vxlan_set_mac(vxlan, vs, skb, vni))1761			goto drop;1762	} else {1763		skb_reset_mac_header(skb);1764		skb->dev = vxlan->dev;1765		skb->pkt_type = PACKET_HOST;1766	}1767 1768	/* Save offset of outer header relative to skb->head,1769	 * because we are going to reset the network header to the inner header1770	 * and might change skb->head.1771	 */1772	nh = skb_network_header(skb) - skb->head;1773 1774	skb_reset_network_header(skb);1775 1776	if (!pskb_inet_may_pull(skb)) {1777		DEV_STATS_INC(vxlan->dev, rx_length_errors);1778		DEV_STATS_INC(vxlan->dev, rx_errors);1779		vxlan_vnifilter_count(vxlan, vni, vninode,1780				      VXLAN_VNI_STATS_RX_ERRORS, 0);1781		goto drop;1782	}1783 1784	/* Get the outer header. */1785	oiph = skb->head + nh;1786 1787	if (!vxlan_ecn_decapsulate(vs, oiph, skb)) {1788		DEV_STATS_INC(vxlan->dev, rx_frame_errors);1789		DEV_STATS_INC(vxlan->dev, rx_errors);1790		vxlan_vnifilter_count(vxlan, vni, vninode,1791				      VXLAN_VNI_STATS_RX_ERRORS, 0);1792		goto drop;1793	}1794 1795	rcu_read_lock();1796 1797	if (unlikely(!(vxlan->dev->flags & IFF_UP))) {1798		rcu_read_unlock();1799		dev_core_stats_rx_dropped_inc(vxlan->dev);1800		vxlan_vnifilter_count(vxlan, vni, vninode,1801				      VXLAN_VNI_STATS_RX_DROPS, 0);1802		goto drop;1803	}1804 1805	dev_sw_netstats_rx_add(vxlan->dev, skb->len);1806	vxlan_vnifilter_count(vxlan, vni, vninode, VXLAN_VNI_STATS_RX, skb->len);1807	gro_cells_receive(&vxlan->gro_cells, skb);1808 1809	rcu_read_unlock();1810 1811	return 0;1812 1813drop:1814	/* Consume bad packet */1815	kfree_skb(skb);1816	return 0;1817}1818 1819/* Callback from net/ipv{4,6}/udp.c to check that we have a VNI for errors */1820static int vxlan_err_lookup(struct sock *sk, struct sk_buff *skb)1821{1822	struct vxlan_dev *vxlan;1823	struct vxlan_sock *vs;1824	struct vxlanhdr *hdr;1825	__be32 vni;1826 1827	if (!pskb_may_pull(skb, skb_transport_offset(skb) + VXLAN_HLEN))1828		return -EINVAL;1829 1830	hdr = vxlan_hdr(skb);1831 1832	if (!(hdr->vx_flags & VXLAN_HF_VNI))1833		return -EINVAL;1834 1835	vs = rcu_dereference_sk_user_data(sk);1836	if (!vs)1837		return -ENOENT;1838 1839	vni = vxlan_vni(hdr->vx_vni);1840	vxlan = vxlan_vs_find_vni(vs, skb->dev->ifindex, vni, NULL);1841	if (!vxlan)1842		return -ENOENT;1843 1844	return 0;1845}1846 1847static int arp_reduce(struct net_device *dev, struct sk_buff *skb, __be32 vni)1848{1849	struct vxlan_dev *vxlan = netdev_priv(dev);1850	struct arphdr *parp;1851	u8 *arpptr, *sha;1852	__be32 sip, tip;1853	struct neighbour *n;1854 1855	if (dev->flags & IFF_NOARP)1856		goto out;1857 1858	if (!pskb_may_pull(skb, arp_hdr_len(dev))) {1859		dev_core_stats_tx_dropped_inc(dev);1860		vxlan_vnifilter_count(vxlan, vni, NULL,1861				      VXLAN_VNI_STATS_TX_DROPS, 0);1862		goto out;1863	}1864	parp = arp_hdr(skb);1865 1866	if ((parp->ar_hrd != htons(ARPHRD_ETHER) &&1867	     parp->ar_hrd != htons(ARPHRD_IEEE802)) ||1868	    parp->ar_pro != htons(ETH_P_IP) ||1869	    parp->ar_op != htons(ARPOP_REQUEST) ||1870	    parp->ar_hln != dev->addr_len ||1871	    parp->ar_pln != 4)1872		goto out;1873	arpptr = (u8 *)parp + sizeof(struct arphdr);1874	sha = arpptr;1875	arpptr += dev->addr_len;	/* sha */1876	memcpy(&sip, arpptr, sizeof(sip));1877	arpptr += sizeof(sip);1878	arpptr += dev->addr_len;	/* tha */1879	memcpy(&tip, arpptr, sizeof(tip));1880 1881	if (ipv4_is_loopback(tip) ||1882	    ipv4_is_multicast(tip))1883		goto out;1884 1885	n = neigh_lookup(&arp_tbl, &tip, dev);1886 1887	if (n) {1888		struct vxlan_fdb *f;1889		struct sk_buff	*reply;1890 1891		if (!(READ_ONCE(n->nud_state) & NUD_CONNECTED)) {1892			neigh_release(n);1893			goto out;1894		}1895 1896		f = vxlan_find_mac(vxlan, n->ha, vni);1897		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {1898			/* bridge-local neighbor */1899			neigh_release(n);1900			goto out;1901		}1902 1903		reply = arp_create(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,1904				n->ha, sha);1905 1906		neigh_release(n);1907 1908		if (reply == NULL)1909			goto out;1910 1911		skb_reset_mac_header(reply);1912		__skb_pull(reply, skb_network_offset(reply));1913		reply->ip_summed = CHECKSUM_UNNECESSARY;1914		reply->pkt_type = PACKET_HOST;1915 1916		if (netif_rx(reply) == NET_RX_DROP) {1917			dev_core_stats_rx_dropped_inc(dev);1918			vxlan_vnifilter_count(vxlan, vni, NULL,1919					      VXLAN_VNI_STATS_RX_DROPS, 0);1920		}1921 1922	} else if (vxlan->cfg.flags & VXLAN_F_L3MISS) {1923		union vxlan_addr ipa = {1924			.sin.sin_addr.s_addr = tip,1925			.sin.sin_family = AF_INET,1926		};1927 1928		vxlan_ip_miss(dev, &ipa);1929	}1930out:1931	consume_skb(skb);1932	return NETDEV_TX_OK;1933}1934 1935#if IS_ENABLED(CONFIG_IPV6)1936static struct sk_buff *vxlan_na_create(struct sk_buff *request,1937	struct neighbour *n, bool isrouter)1938{1939	struct net_device *dev = request->dev;1940	struct sk_buff *reply;1941	struct nd_msg *ns, *na;1942	struct ipv6hdr *pip6;1943	u8 *daddr;1944	int na_olen = 8; /* opt hdr + ETH_ALEN for target */1945	int ns_olen;1946	int i, len;1947 1948	if (dev == NULL || !pskb_may_pull(request, request->len))1949		return NULL;1950 1951	len = LL_RESERVED_SPACE(dev) + sizeof(struct ipv6hdr) +1952		sizeof(*na) + na_olen + dev->needed_tailroom;1953	reply = alloc_skb(len, GFP_ATOMIC);1954	if (reply == NULL)1955		return NULL;1956 1957	reply->protocol = htons(ETH_P_IPV6);1958	reply->dev = dev;1959	skb_reserve(reply, LL_RESERVED_SPACE(request->dev));1960	skb_push(reply, sizeof(struct ethhdr));1961	skb_reset_mac_header(reply);1962 1963	ns = (struct nd_msg *)(ipv6_hdr(request) + 1);1964 1965	daddr = eth_hdr(request)->h_source;1966	ns_olen = request->len - skb_network_offset(request) -1967		sizeof(struct ipv6hdr) - sizeof(*ns);1968	for (i = 0; i < ns_olen-1; i += (ns->opt[i+1]<<3)) {1969		if (!ns->opt[i + 1]) {1970			kfree_skb(reply);1971			return NULL;1972		}1973		if (ns->opt[i] == ND_OPT_SOURCE_LL_ADDR) {1974			daddr = ns->opt + i + sizeof(struct nd_opt_hdr);1975			break;1976		}1977	}1978 1979	/* Ethernet header */1980	ether_addr_copy(eth_hdr(reply)->h_dest, daddr);1981	ether_addr_copy(eth_hdr(reply)->h_source, n->ha);1982	eth_hdr(reply)->h_proto = htons(ETH_P_IPV6);1983	reply->protocol = htons(ETH_P_IPV6);1984 1985	skb_pull(reply, sizeof(struct ethhdr));1986	skb_reset_network_header(reply);1987	skb_put(reply, sizeof(struct ipv6hdr));1988 1989	/* IPv6 header */1990 1991	pip6 = ipv6_hdr(reply);1992	memset(pip6, 0, sizeof(struct ipv6hdr));1993	pip6->version = 6;1994	pip6->priority = ipv6_hdr(request)->priority;1995	pip6->nexthdr = IPPROTO_ICMPV6;1996	pip6->hop_limit = 255;1997	pip6->daddr = ipv6_hdr(request)->saddr;1998	pip6->saddr = *(struct in6_addr *)n->primary_key;1999 2000	skb_pull(reply, sizeof(struct ipv6hdr));2001	skb_reset_transport_header(reply);2002 2003	/* Neighbor Advertisement */2004	na = skb_put_zero(reply, sizeof(*na) + na_olen);2005	na->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;2006	na->icmph.icmp6_router = isrouter;2007	na->icmph.icmp6_override = 1;2008	na->icmph.icmp6_solicited = 1;2009	na->target = ns->target;2010	ether_addr_copy(&na->opt[2], n->ha);2011	na->opt[0] = ND_OPT_TARGET_LL_ADDR;2012	na->opt[1] = na_olen >> 3;2013 2014	na->icmph.icmp6_cksum = csum_ipv6_magic(&pip6->saddr,2015		&pip6->daddr, sizeof(*na)+na_olen, IPPROTO_ICMPV6,2016		csum_partial(na, sizeof(*na)+na_olen, 0));2017 2018	pip6->payload_len = htons(sizeof(*na)+na_olen);2019 2020	skb_push(reply, sizeof(struct ipv6hdr));2021 2022	reply->ip_summed = CHECKSUM_UNNECESSARY;2023 2024	return reply;2025}2026 2027static int neigh_reduce(struct net_device *dev, struct sk_buff *skb, __be32 vni)2028{2029	struct vxlan_dev *vxlan = netdev_priv(dev);2030	const struct in6_addr *daddr;2031	const struct ipv6hdr *iphdr;2032	struct inet6_dev *in6_dev;2033	struct neighbour *n;2034	struct nd_msg *msg;2035 2036	rcu_read_lock();2037	in6_dev = __in6_dev_get(dev);2038	if (!in6_dev)2039		goto out;2040 2041	iphdr = ipv6_hdr(skb);2042	daddr = &iphdr->daddr;2043	msg = (struct nd_msg *)(iphdr + 1);2044 2045	if (ipv6_addr_loopback(daddr) ||2046	    ipv6_addr_is_multicast(&msg->target))2047		goto out;2048 2049	n = neigh_lookup(ipv6_stub->nd_tbl, &msg->target, dev);2050 2051	if (n) {2052		struct vxlan_fdb *f;2053		struct sk_buff *reply;2054 2055		if (!(READ_ONCE(n->nud_state) & NUD_CONNECTED)) {2056			neigh_release(n);2057			goto out;2058		}2059 2060		f = vxlan_find_mac(vxlan, n->ha, vni);2061		if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {2062			/* bridge-local neighbor */2063			neigh_release(n);2064			goto out;2065		}2066 2067		reply = vxlan_na_create(skb, n,2068					!!(f ? f->flags & NTF_ROUTER : 0));2069 2070		neigh_release(n);2071 2072		if (reply == NULL)2073			goto out;2074 2075		if (netif_rx(reply) == NET_RX_DROP) {2076			dev_core_stats_rx_dropped_inc(dev);2077			vxlan_vnifilter_count(vxlan, vni, NULL,2078					      VXLAN_VNI_STATS_RX_DROPS, 0);2079		}2080	} else if (vxlan->cfg.flags & VXLAN_F_L3MISS) {2081		union vxlan_addr ipa = {2082			.sin6.sin6_addr = msg->target,2083			.sin6.sin6_family = AF_INET6,2084		};2085 2086		vxlan_ip_miss(dev, &ipa);2087	}2088 2089out:2090	rcu_read_unlock();2091	consume_skb(skb);2092	return NETDEV_TX_OK;2093}2094#endif2095 2096static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)2097{2098	struct vxlan_dev *vxlan = netdev_priv(dev);2099	struct neighbour *n;2100 2101	if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))2102		return false;2103 2104	n = NULL;2105	switch (ntohs(eth_hdr(skb)->h_proto)) {2106	case ETH_P_IP:2107	{2108		struct iphdr *pip;2109 2110		if (!pskb_may_pull(skb, sizeof(struct iphdr)))2111			return false;2112		pip = ip_hdr(skb);2113		n = neigh_lookup(&arp_tbl, &pip->daddr, dev);2114		if (!n && (vxlan->cfg.flags & VXLAN_F_L3MISS)) {2115			union vxlan_addr ipa = {2116				.sin.sin_addr.s_addr = pip->daddr,2117				.sin.sin_family = AF_INET,2118			};2119 2120			vxlan_ip_miss(dev, &ipa);2121			return false;2122		}2123 2124		break;2125	}2126#if IS_ENABLED(CONFIG_IPV6)2127	case ETH_P_IPV6:2128	{2129		struct ipv6hdr *pip6;2130 2131		if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))2132			return false;2133		pip6 = ipv6_hdr(skb);2134		n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev);2135		if (!n && (vxlan->cfg.flags & VXLAN_F_L3MISS)) {2136			union vxlan_addr ipa = {2137				.sin6.sin6_addr = pip6->daddr,2138				.sin6.sin6_family = AF_INET6,2139			};2140 2141			vxlan_ip_miss(dev, &ipa);2142			return false;2143		}2144 2145		break;2146	}2147#endif2148	default:2149		return false;2150	}2151 2152	if (n) {2153		bool diff;2154 2155		diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);2156		if (diff) {2157			memcpy(eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest,2158				dev->addr_len);2159			memcpy(eth_hdr(skb)->h_dest, n->ha, dev->addr_len);2160		}2161		neigh_release(n);2162		return diff;2163	}2164 2165	return false;2166}2167 2168static int vxlan_build_gpe_hdr(struct vxlanhdr *vxh, __be16 protocol)2169{2170	struct vxlanhdr_gpe *gpe = (struct vxlanhdr_gpe *)vxh;2171 2172	gpe->np_applied = 1;2173	gpe->next_protocol = tun_p_from_eth_p(protocol);2174	if (!gpe->next_protocol)2175		return -EPFNOSUPPORT;2176	return 0;2177}2178 2179static int vxlan_build_skb(struct sk_buff *skb, struct dst_entry *dst,2180			   int iphdr_len, __be32 vni,2181			   struct vxlan_metadata *md, u32 vxflags,2182			   bool udp_sum)2183{2184	struct vxlanhdr *vxh;2185	int min_headroom;2186	int err;2187	int type = udp_sum ? SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;2188	__be16 inner_protocol = htons(ETH_P_TEB);2189 2190	if ((vxflags & VXLAN_F_REMCSUM_TX) &&2191	    skb->ip_summed == CHECKSUM_PARTIAL) {2192		int csum_start = skb_checksum_start_offset(skb);2193 2194		if (csum_start <= VXLAN_MAX_REMCSUM_START &&2195		    !(csum_start & VXLAN_RCO_SHIFT_MASK) &&2196		    (skb->csum_offset == offsetof(struct udphdr, check) ||2197		     skb->csum_offset == offsetof(struct tcphdr, check)))2198			type |= SKB_GSO_TUNNEL_REMCSUM;2199	}2200 2201	min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len2202			+ VXLAN_HLEN + iphdr_len;2203 2204	/* Need space for new headers (invalidates iph ptr) */2205	err = skb_cow_head(skb, min_headroom);2206	if (unlikely(err))2207		return err;2208 2209	err = iptunnel_handle_offloads(skb, type);2210	if (err)2211		return err;2212 2213	vxh = __skb_push(skb, sizeof(*vxh));2214	vxh->vx_flags = VXLAN_HF_VNI;2215	vxh->vx_vni = vxlan_vni_field(vni);2216 2217	if (type & SKB_GSO_TUNNEL_REMCSUM) {2218		unsigned int start;2219 2220		start = skb_checksum_start_offset(skb) - sizeof(struct vxlanhdr);2221		vxh->vx_vni |= vxlan_compute_rco(start, skb->csum_offset);2222		vxh->vx_flags |= VXLAN_HF_RCO;2223 2224		if (!skb_is_gso(skb)) {2225			skb->ip_summed = CHECKSUM_NONE;2226			skb->encapsulation = 0;2227		}2228	}2229 2230	if (vxflags & VXLAN_F_GBP)2231		vxlan_build_gbp_hdr(vxh, md);2232	if (vxflags & VXLAN_F_GPE) {2233		err = vxlan_build_gpe_hdr(vxh, skb->protocol);2234		if (err < 0)2235			return err;2236		inner_protocol = skb->protocol;2237	}2238 2239	skb_set_inner_protocol(skb, inner_protocol);2240	return 0;2241}2242 2243/* Bypass encapsulation if the destination is local */2244static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan,2245			       struct vxlan_dev *dst_vxlan, __be32 vni,2246			       bool snoop)2247{2248	union vxlan_addr loopback;2249	union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;2250	struct net_device *dev;2251	int len = skb->len;2252 2253	skb->pkt_type = PACKET_HOST;2254	skb->encapsulation = 0;2255	skb->dev = dst_vxlan->dev;2256	__skb_pull(skb, skb_network_offset(skb));2257 2258	if (remote_ip->sa.sa_family == AF_INET) {2259		loopback.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);2260		loopback.sa.sa_family =  AF_INET;2261#if IS_ENABLED(CONFIG_IPV6)2262	} else {2263		loopback.sin6.sin6_addr = in6addr_loopback;2264		loopback.sa.sa_family =  AF_INET6;2265#endif2266	}2267 2268	rcu_read_lock();2269	dev = skb->dev;2270	if (unlikely(!(dev->flags & IFF_UP))) {2271		kfree_skb(skb);2272		goto drop;2273	}2274 2275	if ((dst_vxlan->cfg.flags & VXLAN_F_LEARN) && snoop)2276		vxlan_snoop(dev, &loopback, eth_hdr(skb)->h_source, 0, vni);2277 2278	dev_sw_netstats_tx_add(src_vxlan->dev, 1, len);2279	vxlan_vnifilter_count(src_vxlan, vni, NULL, VXLAN_VNI_STATS_TX, len);2280 2281	if (__netif_rx(skb) == NET_RX_SUCCESS) {2282		dev_sw_netstats_rx_add(dst_vxlan->dev, len);2283		vxlan_vnifilter_count(dst_vxlan, vni, NULL, VXLAN_VNI_STATS_RX,2284				      len);2285	} else {2286drop:2287		dev_core_stats_rx_dropped_inc(dev);2288		vxlan_vnifilter_count(dst_vxlan, vni, NULL,2289				      VXLAN_VNI_STATS_RX_DROPS, 0);2290	}2291	rcu_read_unlock();2292}2293 2294static int encap_bypass_if_local(struct sk_buff *skb, struct net_device *dev,2295				 struct vxlan_dev *vxlan,2296				 int addr_family,2297				 __be16 dst_port, int dst_ifindex, __be32 vni,2298				 struct dst_entry *dst,2299				 u32 rt_flags)2300{2301#if IS_ENABLED(CONFIG_IPV6)2302	/* IPv6 rt-flags are checked against RTF_LOCAL, but the value of2303	 * RTF_LOCAL is equal to RTCF_LOCAL. So to keep code simple2304	 * we can use RTCF_LOCAL which works for ipv4 and ipv6 route entry.2305	 */2306	BUILD_BUG_ON(RTCF_LOCAL != RTF_LOCAL);2307#endif2308	/* Bypass encapsulation if the destination is local */2309	if (rt_flags & RTCF_LOCAL &&2310	    !(rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) &&2311	    vxlan->cfg.flags & VXLAN_F_LOCALBYPASS) {2312		struct vxlan_dev *dst_vxlan;2313 2314		dst_release(dst);2315		dst_vxlan = vxlan_find_vni(vxlan->net, dst_ifindex, vni,2316					   addr_family, dst_port,2317					   vxlan->cfg.flags);2318		if (!dst_vxlan) {2319			DEV_STATS_INC(dev, tx_errors);2320			vxlan_vnifilter_count(vxlan, vni, NULL,2321					      VXLAN_VNI_STATS_TX_ERRORS, 0);2322			kfree_skb(skb);2323 2324			return -ENOENT;2325		}2326		vxlan_encap_bypass(skb, vxlan, dst_vxlan, vni, true);2327		return 1;2328	}2329 2330	return 0;2331}2332 2333void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,2334		    __be32 default_vni, struct vxlan_rdst *rdst, bool did_rsc)2335{2336	struct dst_cache *dst_cache;2337	struct ip_tunnel_info *info;2338	struct ip_tunnel_key *pkey;2339	struct ip_tunnel_key key;2340	struct vxlan_dev *vxlan = netdev_priv(dev);2341	const struct iphdr *old_iph;2342	struct vxlan_metadata _md;2343	struct vxlan_metadata *md = &_md;2344	unsigned int pkt_len = skb->len;2345	__be16 src_port = 0, dst_port;2346	struct dst_entry *ndst = NULL;2347	int addr_family;2348	__u8 tos, ttl;2349	int ifindex;2350	int err;2351	u32 flags = vxlan->cfg.flags;2352	bool use_cache;2353	bool udp_sum = false;2354	bool xnet = !net_eq(vxlan->net, dev_net(vxlan->dev));2355	bool no_eth_encap;2356	__be32 vni = 0;2357 2358	no_eth_encap = flags & VXLAN_F_GPE && skb->protocol != htons(ETH_P_TEB);2359	if (!skb_vlan_inet_prepare(skb, no_eth_encap))2360		goto drop;2361 2362	old_iph = ip_hdr(skb);2363 2364	info = skb_tunnel_info(skb);2365	use_cache = ip_tunnel_dst_cache_usable(skb, info);2366 2367	if (rdst) {2368		memset(&key, 0, sizeof(key));2369		pkey = &key;2370 2371		if (vxlan_addr_any(&rdst->remote_ip)) {2372			if (did_rsc) {2373				/* short-circuited back to local bridge */2374				vxlan_encap_bypass(skb, vxlan, vxlan,2375						   default_vni, true);2376				return;2377			}2378			goto drop;2379		}2380 2381		addr_family = vxlan->cfg.saddr.sa.sa_family;2382		dst_port = rdst->remote_port ? rdst->remote_port : vxlan->cfg.dst_port;2383		vni = (rdst->remote_vni) ? : default_vni;2384		ifindex = rdst->remote_ifindex;2385 2386		if (addr_family == AF_INET) {2387			key.u.ipv4.src = vxlan->cfg.saddr.sin.sin_addr.s_addr;2388			key.u.ipv4.dst = rdst->remote_ip.sin.sin_addr.s_addr;2389		} else {2390			key.u.ipv6.src = vxlan->cfg.saddr.sin6.sin6_addr;2391			key.u.ipv6.dst = rdst->remote_ip.sin6.sin6_addr;2392		}2393 2394		dst_cache = &rdst->dst_cache;2395		md->gbp = skb->mark;2396		if (flags & VXLAN_F_TTL_INHERIT) {2397			ttl = ip_tunnel_get_ttl(old_iph, skb);2398		} else {2399			ttl = vxlan->cfg.ttl;2400			if (!ttl && vxlan_addr_multicast(&rdst->remote_ip))2401				ttl = 1;2402		}2403		tos = vxlan->cfg.tos;2404		if (tos == 1)2405			tos = ip_tunnel_get_dsfield(old_iph, skb);2406		if (tos && !info)2407			use_cache = false;2408 2409		if (addr_family == AF_INET)2410			udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM_TX);2411		else2412			udp_sum = !(flags & VXLAN_F_UDP_ZERO_CSUM6_TX);2413#if IS_ENABLED(CONFIG_IPV6)2414		switch (vxlan->cfg.label_policy) {2415		case VXLAN_LABEL_FIXED:2416			key.label = vxlan->cfg.label;2417			break;2418		case VXLAN_LABEL_INHERIT:2419			key.label = ip_tunnel_get_flowlabel(old_iph, skb);2420			break;2421		default:2422			DEBUG_NET_WARN_ON_ONCE(1);2423			goto drop;2424		}2425#endif2426	} else {2427		if (!info) {2428			WARN_ONCE(1, "%s: Missing encapsulation instructions\n",2429				  dev->name);2430			goto drop;2431		}2432		pkey = &info->key;2433		addr_family = ip_tunnel_info_af(info);2434		dst_port = info->key.tp_dst ? : vxlan->cfg.dst_port;2435		vni = tunnel_id_to_key32(info->key.tun_id);2436		ifindex = 0;2437		dst_cache = &info->dst_cache;2438		if (test_bit(IP_TUNNEL_VXLAN_OPT_BIT, info->key.tun_flags)) {2439			if (info->options_len < sizeof(*md))2440				goto drop;2441			md = ip_tunnel_info_opts(info);2442		}2443		ttl = info->key.ttl;2444		tos = info->key.tos;2445		udp_sum = test_bit(IP_TUNNEL_CSUM_BIT, info->key.tun_flags);2446	}2447	src_port = udp_flow_src_port(dev_net(dev), skb, vxlan->cfg.port_min,2448				     vxlan->cfg.port_max, true);2449 2450	rcu_read_lock();2451	if (addr_family == AF_INET) {2452		struct vxlan_sock *sock4 = rcu_dereference(vxlan->vn4_sock);2453		struct rtable *rt;2454		__be16 df = 0;2455		__be32 saddr;2456 2457		if (!ifindex)2458			ifindex = sock4->sock->sk->sk_bound_dev_if;2459 2460		rt = udp_tunnel_dst_lookup(skb, dev, vxlan->net, ifindex,2461					   &saddr, pkey, src_port, dst_port,2462					   tos, use_cache ? dst_cache : NULL);2463		if (IS_ERR(rt)) {2464			err = PTR_ERR(rt);2465			goto tx_error;2466		}2467 2468		if (!info) {2469			/* Bypass encapsulation if the destination is local */2470			err = encap_bypass_if_local(skb, dev, vxlan, AF_INET,2471						    dst_port, ifindex, vni,2472						    &rt->dst, rt->rt_flags);2473			if (err)2474				goto out_unlock;2475 2476			if (vxlan->cfg.df == VXLAN_DF_SET) {2477				df = htons(IP_DF);2478			} else if (vxlan->cfg.df == VXLAN_DF_INHERIT) {2479				struct ethhdr *eth = eth_hdr(skb);2480 2481				if (ntohs(eth->h_proto) == ETH_P_IPV6 ||2482				    (ntohs(eth->h_proto) == ETH_P_IP &&2483				     old_iph->frag_off & htons(IP_DF)))2484					df = htons(IP_DF);2485			}2486		} else if (test_bit(IP_TUNNEL_DONT_FRAGMENT_BIT,2487				    info->key.tun_flags)) {2488			df = htons(IP_DF);2489		}2490 2491		ndst = &rt->dst;2492		err = skb_tunnel_check_pmtu(skb, ndst, vxlan_headroom(flags & VXLAN_F_GPE),2493					    netif_is_any_bridge_port(dev));2494		if (err < 0) {2495			goto tx_error;2496		} else if (err) {2497			if (info) {2498				struct ip_tunnel_info *unclone;2499 2500				unclone = skb_tunnel_info_unclone(skb);2501				if (unlikely(!unclone))2502					goto tx_error;2503 2504				unclone->key.u.ipv4.src = pkey->u.ipv4.dst;2505				unclone->key.u.ipv4.dst = saddr;2506			}2507			vxlan_encap_bypass(skb, vxlan, vxlan, vni, false);2508			dst_release(ndst);2509			goto out_unlock;2510		}2511 2512		tos = ip_tunnel_ecn_encap(tos, old_iph, skb);2513		ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);2514		err = vxlan_build_skb(skb, ndst, sizeof(struct iphdr),2515				      vni, md, flags, udp_sum);2516		if (err < 0)2517			goto tx_error;2518 2519		udp_tunnel_xmit_skb(rt, sock4->sock->sk, skb, saddr,2520				    pkey->u.ipv4.dst, tos, ttl, df,2521				    src_port, dst_port, xnet, !udp_sum);2522#if IS_ENABLED(CONFIG_IPV6)2523	} else {2524		struct vxlan_sock *sock6 = rcu_dereference(vxlan->vn6_sock);2525		struct in6_addr saddr;2526 2527		if (!ifindex)2528			ifindex = sock6->sock->sk->sk_bound_dev_if;2529 2530		ndst = udp_tunnel6_dst_lookup(skb, dev, vxlan->net, sock6->sock,2531					      ifindex, &saddr, pkey,2532					      src_port, dst_port, tos,2533					      use_cache ? dst_cache : NULL);2534		if (IS_ERR(ndst)) {2535			err = PTR_ERR(ndst);2536			ndst = NULL;2537			goto tx_error;2538		}2539 2540		if (!info) {2541			u32 rt6i_flags = dst_rt6_info(ndst)->rt6i_flags;2542 2543			err = encap_bypass_if_local(skb, dev, vxlan, AF_INET6,2544						    dst_port, ifindex, vni,2545						    ndst, rt6i_flags);2546			if (err)2547				goto out_unlock;2548		}2549 2550		err = skb_tunnel_check_pmtu(skb, ndst,2551					    vxlan_headroom((flags & VXLAN_F_GPE) | VXLAN_F_IPV6),2552					    netif_is_any_bridge_port(dev));2553		if (err < 0) {2554			goto tx_error;2555		} else if (err) {2556			if (info) {2557				struct ip_tunnel_info *unclone;2558 2559				unclone = skb_tunnel_info_unclone(skb);2560				if (unlikely(!unclone))2561					goto tx_error;2562 2563				unclone->key.u.ipv6.src = pkey->u.ipv6.dst;2564				unclone->key.u.ipv6.dst = saddr;2565			}2566 2567			vxlan_encap_bypass(skb, vxlan, vxlan, vni, false);2568			dst_release(ndst);2569			goto out_unlock;2570		}2571 2572		tos = ip_tunnel_ecn_encap(tos, old_iph, skb);2573		ttl = ttl ? : ip6_dst_hoplimit(ndst);2574		skb_scrub_packet(skb, xnet);2575		err = vxlan_build_skb(skb, ndst, sizeof(struct ipv6hdr),2576				      vni, md, flags, udp_sum);2577		if (err < 0)2578			goto tx_error;2579 2580		udp_tunnel6_xmit_skb(ndst, sock6->sock->sk, skb, dev,2581				     &saddr, &pkey->u.ipv6.dst, tos, ttl,2582				     pkey->label, src_port, dst_port, !udp_sum);2583#endif2584	}2585	vxlan_vnifilter_count(vxlan, vni, NULL, VXLAN_VNI_STATS_TX, pkt_len);2586out_unlock:2587	rcu_read_unlock();2588	return;2589 2590drop:2591	dev_core_stats_tx_dropped_inc(dev);2592	vxlan_vnifilter_count(vxlan, vni, NULL, VXLAN_VNI_STATS_TX_DROPS, 0);2593	dev_kfree_skb(skb);2594	return;2595 2596tx_error:2597	rcu_read_unlock();2598	if (err == -ELOOP)2599		DEV_STATS_INC(dev, collisions);2600	else if (err == -ENETUNREACH)2601		DEV_STATS_INC(dev, tx_carrier_errors);2602	dst_release(ndst);2603	DEV_STATS_INC(dev, tx_errors);2604	vxlan_vnifilter_count(vxlan, vni, NULL, VXLAN_VNI_STATS_TX_ERRORS, 0);2605	kfree_skb(skb);2606}2607 2608static void vxlan_xmit_nh(struct sk_buff *skb, struct net_device *dev,2609			  struct vxlan_fdb *f, __be32 vni, bool did_rsc)2610{2611	struct vxlan_rdst nh_rdst;2612	struct nexthop *nh;2613	bool do_xmit;2614	u32 hash;2615 2616	memset(&nh_rdst, 0, sizeof(struct vxlan_rdst));2617	hash = skb_get_hash(skb);2618 2619	rcu_read_lock();2620	nh = rcu_dereference(f->nh);2621	if (!nh) {2622		rcu_read_unlock();2623		goto drop;2624	}2625	do_xmit = vxlan_fdb_nh_path_select(nh, hash, &nh_rdst);2626	rcu_read_unlock();2627 2628	if (likely(do_xmit))2629		vxlan_xmit_one(skb, dev, vni, &nh_rdst, did_rsc);2630	else2631		goto drop;2632 2633	return;2634 2635drop:2636	dev_core_stats_tx_dropped_inc(dev);2637	vxlan_vnifilter_count(netdev_priv(dev), vni, NULL,2638			      VXLAN_VNI_STATS_TX_DROPS, 0);2639	dev_kfree_skb(skb);2640}2641 2642static netdev_tx_t vxlan_xmit_nhid(struct sk_buff *skb, struct net_device *dev,2643				   u32 nhid, __be32 vni)2644{2645	struct vxlan_dev *vxlan = netdev_priv(dev);2646	struct vxlan_rdst nh_rdst;2647	struct nexthop *nh;2648	bool do_xmit;2649	u32 hash;2650 2651	memset(&nh_rdst, 0, sizeof(struct vxlan_rdst));2652	hash = skb_get_hash(skb);2653 2654	rcu_read_lock();2655	nh = nexthop_find_by_id(dev_net(dev), nhid);2656	if (unlikely(!nh || !nexthop_is_fdb(nh) || !nexthop_is_multipath(nh))) {2657		rcu_read_unlock();2658		goto drop;2659	}2660	do_xmit = vxlan_fdb_nh_path_select(nh, hash, &nh_rdst);2661	rcu_read_unlock();2662 2663	if (vxlan->cfg.saddr.sa.sa_family != nh_rdst.remote_ip.sa.sa_family)2664		goto drop;2665 2666	if (likely(do_xmit))2667		vxlan_xmit_one(skb, dev, vni, &nh_rdst, false);2668	else2669		goto drop;2670 2671	return NETDEV_TX_OK;2672 2673drop:2674	dev_core_stats_tx_dropped_inc(dev);2675	vxlan_vnifilter_count(netdev_priv(dev), vni, NULL,2676			      VXLAN_VNI_STATS_TX_DROPS, 0);2677	dev_kfree_skb(skb);2678	return NETDEV_TX_OK;2679}2680 2681/* Transmit local packets over Vxlan2682 *2683 * Outer IP header inherits ECN and DF from inner header.2684 * Outer UDP destination is the VXLAN assigned port.2685 *           source port is based on hash of flow2686 */2687static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)2688{2689	struct vxlan_dev *vxlan = netdev_priv(dev);2690	struct vxlan_rdst *rdst, *fdst = NULL;2691	const struct ip_tunnel_info *info;2692	struct vxlan_fdb *f;2693	struct ethhdr *eth;2694	__be32 vni = 0;2695	u32 nhid = 0;2696	bool did_rsc;2697 2698	info = skb_tunnel_info(skb);2699 2700	skb_reset_mac_header(skb);2701 2702	if (vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA) {2703		if (info && info->mode & IP_TUNNEL_INFO_BRIDGE &&2704		    info->mode & IP_TUNNEL_INFO_TX) {2705			vni = tunnel_id_to_key32(info->key.tun_id);2706			nhid = info->key.nhid;2707		} else {2708			if (info && info->mode & IP_TUNNEL_INFO_TX)2709				vxlan_xmit_one(skb, dev, vni, NULL, false);2710			else2711				kfree_skb(skb);2712			return NETDEV_TX_OK;2713		}2714	}2715 2716	if (vxlan->cfg.flags & VXLAN_F_PROXY) {2717		eth = eth_hdr(skb);2718		if (ntohs(eth->h_proto) == ETH_P_ARP)2719			return arp_reduce(dev, skb, vni);2720#if IS_ENABLED(CONFIG_IPV6)2721		else if (ntohs(eth->h_proto) == ETH_P_IPV6 &&2722			 pskb_may_pull(skb, sizeof(struct ipv6hdr) +2723					    sizeof(struct nd_msg)) &&2724			 ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {2725			struct nd_msg *m = (struct nd_msg *)(ipv6_hdr(skb) + 1);2726 2727			if (m->icmph.icmp6_code == 0 &&2728			    m->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION)2729				return neigh_reduce(dev, skb, vni);2730		}2731#endif2732	}2733 2734	if (nhid)2735		return vxlan_xmit_nhid(skb, dev, nhid, vni);2736 2737	if (vxlan->cfg.flags & VXLAN_F_MDB) {2738		struct vxlan_mdb_entry *mdb_entry;2739 2740		rcu_read_lock();2741		mdb_entry = vxlan_mdb_entry_skb_get(vxlan, skb, vni);2742		if (mdb_entry) {2743			netdev_tx_t ret;2744 2745			ret = vxlan_mdb_xmit(vxlan, mdb_entry, skb);2746			rcu_read_unlock();2747			return ret;2748		}2749		rcu_read_unlock();2750	}2751 2752	eth = eth_hdr(skb);2753	f = vxlan_find_mac(vxlan, eth->h_dest, vni);2754	did_rsc = false;2755 2756	if (f && (f->flags & NTF_ROUTER) && (vxlan->cfg.flags & VXLAN_F_RSC) &&2757	    (ntohs(eth->h_proto) == ETH_P_IP ||2758	     ntohs(eth->h_proto) == ETH_P_IPV6)) {2759		did_rsc = route_shortcircuit(dev, skb);2760		if (did_rsc)2761			f = vxlan_find_mac(vxlan, eth->h_dest, vni);2762	}2763 2764	if (f == NULL) {2765		f = vxlan_find_mac(vxlan, all_zeros_mac, vni);2766		if (f == NULL) {2767			if ((vxlan->cfg.flags & VXLAN_F_L2MISS) &&2768			    !is_multicast_ether_addr(eth->h_dest))2769				vxlan_fdb_miss(vxlan, eth->h_dest);2770 2771			dev_core_stats_tx_dropped_inc(dev);2772			vxlan_vnifilter_count(vxlan, vni, NULL,2773					      VXLAN_VNI_STATS_TX_DROPS, 0);2774			kfree_skb(skb);2775			return NETDEV_TX_OK;2776		}2777	}2778 2779	if (rcu_access_pointer(f->nh)) {2780		vxlan_xmit_nh(skb, dev, f,2781			      (vni ? : vxlan->default_dst.remote_vni), did_rsc);2782	} else {2783		list_for_each_entry_rcu(rdst, &f->remotes, list) {2784			struct sk_buff *skb1;2785 2786			if (!fdst) {2787				fdst = rdst;2788				continue;2789			}2790			skb1 = skb_clone(skb, GFP_ATOMIC);2791			if (skb1)2792				vxlan_xmit_one(skb1, dev, vni, rdst, did_rsc);2793		}2794		if (fdst)2795			vxlan_xmit_one(skb, dev, vni, fdst, did_rsc);2796		else2797			kfree_skb(skb);2798	}2799 2800	return NETDEV_TX_OK;2801}2802 2803/* Walk the forwarding table and purge stale entries */2804static void vxlan_cleanup(struct timer_list *t)2805{2806	struct vxlan_dev *vxlan = from_timer(vxlan, t, age_timer);2807	unsigned long next_timer = jiffies + FDB_AGE_INTERVAL;2808	unsigned int h;2809 2810	if (!netif_running(vxlan->dev))2811		return;2812 2813	for (h = 0; h < FDB_HASH_SIZE; ++h) {2814		struct hlist_node *p, *n;2815 2816		spin_lock(&vxlan->hash_lock[h]);2817		hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {2818			struct vxlan_fdb *f2819				= container_of(p, struct vxlan_fdb, hlist);2820			unsigned long timeout;2821 2822			if (f->state & (NUD_PERMANENT | NUD_NOARP))2823				continue;2824 2825			if (f->flags & NTF_EXT_LEARNED)2826				continue;2827 2828			timeout = f->used + vxlan->cfg.age_interval * HZ;2829			if (time_before_eq(timeout, jiffies)) {2830				netdev_dbg(vxlan->dev,2831					   "garbage collect %pM\n",2832					   f->eth_addr);2833				f->state = NUD_STALE;2834				vxlan_fdb_destroy(vxlan, f, true, true);2835			} else if (time_before(timeout, next_timer))2836				next_timer = timeout;2837		}2838		spin_unlock(&vxlan->hash_lock[h]);2839	}2840 2841	mod_timer(&vxlan->age_timer, next_timer);2842}2843 2844static void vxlan_vs_del_dev(struct vxlan_dev *vxlan)2845{2846	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);2847 2848	spin_lock(&vn->sock_lock);2849	hlist_del_init_rcu(&vxlan->hlist4.hlist);2850#if IS_ENABLED(CONFIG_IPV6)2851	hlist_del_init_rcu(&vxlan->hlist6.hlist);2852#endif2853	spin_unlock(&vn->sock_lock);2854}2855 2856static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan,2857			     struct vxlan_dev_node *node)2858{2859	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);2860	__be32 vni = vxlan->default_dst.remote_vni;2861 2862	node->vxlan = vxlan;2863	spin_lock(&vn->sock_lock);2864	hlist_add_head_rcu(&node->hlist, vni_head(vs, vni));2865	spin_unlock(&vn->sock_lock);2866}2867 2868/* Setup stats when device is created */2869static int vxlan_init(struct net_device *dev)2870{2871	struct vxlan_dev *vxlan = netdev_priv(dev);2872	int err;2873 2874	if (vxlan->cfg.flags & VXLAN_F_VNIFILTER)2875		vxlan_vnigroup_init(vxlan);2876 2877	err = gro_cells_init(&vxlan->gro_cells, dev);2878	if (err)2879		goto err_vnigroup_uninit;2880 2881	err = vxlan_mdb_init(vxlan);2882	if (err)2883		goto err_gro_cells_destroy;2884 2885	netdev_lockdep_set_classes(dev);2886	return 0;2887 2888err_gro_cells_destroy:2889	gro_cells_destroy(&vxlan->gro_cells);2890err_vnigroup_uninit:2891	if (vxlan->cfg.flags & VXLAN_F_VNIFILTER)2892		vxlan_vnigroup_uninit(vxlan);2893	return err;2894}2895 2896static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan, __be32 vni)2897{2898	struct vxlan_fdb *f;2899	u32 hash_index = fdb_head_index(vxlan, all_zeros_mac, vni);2900 2901	spin_lock_bh(&vxlan->hash_lock[hash_index]);2902	f = __vxlan_find_mac(vxlan, all_zeros_mac, vni);2903	if (f)2904		vxlan_fdb_destroy(vxlan, f, true, true);2905	spin_unlock_bh(&vxlan->hash_lock[hash_index]);2906}2907 2908static void vxlan_uninit(struct net_device *dev)2909{2910	struct vxlan_dev *vxlan = netdev_priv(dev);2911 2912	vxlan_mdb_fini(vxlan);2913 2914	if (vxlan->cfg.flags & VXLAN_F_VNIFILTER)2915		vxlan_vnigroup_uninit(vxlan);2916 2917	gro_cells_destroy(&vxlan->gro_cells);2918 2919	vxlan_fdb_delete_default(vxlan, vxlan->cfg.vni);2920}2921 2922/* Start ageing timer and join group when device is brought up */2923static int vxlan_open(struct net_device *dev)2924{2925	struct vxlan_dev *vxlan = netdev_priv(dev);2926	int ret;2927 2928	ret = vxlan_sock_add(vxlan);2929	if (ret < 0)2930		return ret;2931 2932	ret = vxlan_multicast_join(vxlan);2933	if (ret) {2934		vxlan_sock_release(vxlan);2935		return ret;2936	}2937 2938	if (vxlan->cfg.age_interval)2939		mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);2940 2941	return ret;2942}2943 2944struct vxlan_fdb_flush_desc {2945	bool				ignore_default_entry;2946	unsigned long                   state;2947	unsigned long			state_mask;2948	unsigned long                   flags;2949	unsigned long			flags_mask;2950	__be32				src_vni;2951	u32				nhid;2952	__be32				vni;2953	__be16				port;2954	union vxlan_addr		dst_ip;2955};2956 2957static bool vxlan_fdb_is_default_entry(const struct vxlan_fdb *f,2958				       const struct vxlan_dev *vxlan)2959{2960	return is_zero_ether_addr(f->eth_addr) && f->vni == vxlan->cfg.vni;2961}2962 2963static bool vxlan_fdb_nhid_matches(const struct vxlan_fdb *f, u32 nhid)2964{2965	struct nexthop *nh = rtnl_dereference(f->nh);2966 2967	return nh && nh->id == nhid;2968}2969 2970static bool vxlan_fdb_flush_matches(const struct vxlan_fdb *f,2971				    const struct vxlan_dev *vxlan,2972				    const struct vxlan_fdb_flush_desc *desc)2973{2974	if (desc->state_mask && (f->state & desc->state_mask) != desc->state)2975		return false;2976 2977	if (desc->flags_mask && (f->flags & desc->flags_mask) != desc->flags)2978		return false;2979 2980	if (desc->ignore_default_entry && vxlan_fdb_is_default_entry(f, vxlan))2981		return false;2982 2983	if (desc->src_vni && f->vni != desc->src_vni)2984		return false;2985 2986	if (desc->nhid && !vxlan_fdb_nhid_matches(f, desc->nhid))2987		return false;2988 2989	return true;2990}2991 2992static bool2993vxlan_fdb_flush_should_match_remotes(const struct vxlan_fdb_flush_desc *desc)2994{2995	return desc->vni || desc->port || desc->dst_ip.sa.sa_family;2996}2997 2998static bool2999vxlan_fdb_flush_remote_matches(const struct vxlan_fdb_flush_desc *desc,3000			       const struct vxlan_rdst *rd)3001{3002	if (desc->vni && rd->remote_vni != desc->vni)3003		return false;3004 3005	if (desc->port && rd->remote_port != desc->port)3006		return false;3007 3008	if (desc->dst_ip.sa.sa_family &&3009	    !vxlan_addr_equal(&rd->remote_ip, &desc->dst_ip))3010		return false;3011 3012	return true;3013}3014 3015static void3016vxlan_fdb_flush_match_remotes(struct vxlan_fdb *f, struct vxlan_dev *vxlan,3017			      const struct vxlan_fdb_flush_desc *desc,3018			      bool *p_destroy_fdb)3019{3020	bool remotes_flushed = false;3021	struct vxlan_rdst *rd, *tmp;3022 3023	list_for_each_entry_safe(rd, tmp, &f->remotes, list) {3024		if (!vxlan_fdb_flush_remote_matches(desc, rd))3025			continue;3026 3027		vxlan_fdb_dst_destroy(vxlan, f, rd, true);3028		remotes_flushed = true;3029	}3030 3031	*p_destroy_fdb = remotes_flushed && list_empty(&f->remotes);3032}3033 3034/* Purge the forwarding table */3035static void vxlan_flush(struct vxlan_dev *vxlan,3036			const struct vxlan_fdb_flush_desc *desc)3037{3038	bool match_remotes = vxlan_fdb_flush_should_match_remotes(desc);3039	unsigned int h;3040 3041	for (h = 0; h < FDB_HASH_SIZE; ++h) {3042		struct hlist_node *p, *n;3043 3044		spin_lock_bh(&vxlan->hash_lock[h]);3045		hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {3046			struct vxlan_fdb *f3047				= container_of(p, struct vxlan_fdb, hlist);3048 3049			if (!vxlan_fdb_flush_matches(f, vxlan, desc))3050				continue;3051 3052			if (match_remotes) {3053				bool destroy_fdb = false;3054 3055				vxlan_fdb_flush_match_remotes(f, vxlan, desc,3056							      &destroy_fdb);3057 3058				if (!destroy_fdb)3059					continue;3060			}3061 3062			vxlan_fdb_destroy(vxlan, f, true, true);3063		}3064		spin_unlock_bh(&vxlan->hash_lock[h]);3065	}3066}3067 3068static const struct nla_policy vxlan_del_bulk_policy[NDA_MAX + 1] = {3069	[NDA_SRC_VNI]   = { .type = NLA_U32 },3070	[NDA_NH_ID]	= { .type = NLA_U32 },3071	[NDA_VNI]	= { .type = NLA_U32 },3072	[NDA_PORT]	= { .type = NLA_U16 },3073	[NDA_DST]	= NLA_POLICY_RANGE(NLA_BINARY, sizeof(struct in_addr),3074					   sizeof(struct in6_addr)),3075	[NDA_NDM_STATE_MASK]	= { .type = NLA_U16 },3076	[NDA_NDM_FLAGS_MASK]	= { .type = NLA_U8 },3077};3078 3079#define VXLAN_FDB_FLUSH_IGNORED_NDM_FLAGS (NTF_MASTER | NTF_SELF)3080#define VXLAN_FDB_FLUSH_ALLOWED_NDM_STATES (NUD_PERMANENT | NUD_NOARP)3081#define VXLAN_FDB_FLUSH_ALLOWED_NDM_FLAGS (NTF_EXT_LEARNED | NTF_OFFLOADED | \3082					   NTF_ROUTER)3083 3084static int vxlan_fdb_delete_bulk(struct nlmsghdr *nlh, struct net_device *dev,3085				 struct netlink_ext_ack *extack)3086{3087	struct vxlan_dev *vxlan = netdev_priv(dev);3088	struct vxlan_fdb_flush_desc desc = {};3089	struct ndmsg *ndm = nlmsg_data(nlh);3090	struct nlattr *tb[NDA_MAX + 1];3091	u8 ndm_flags;3092	int err;3093 3094	ndm_flags = ndm->ndm_flags & ~VXLAN_FDB_FLUSH_IGNORED_NDM_FLAGS;3095 3096	err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, vxlan_del_bulk_policy,3097			  extack);3098	if (err)3099		return err;3100 3101	if (ndm_flags & ~VXLAN_FDB_FLUSH_ALLOWED_NDM_FLAGS) {3102		NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm flag bits set");3103		return -EINVAL;3104	}3105	if (ndm->ndm_state & ~VXLAN_FDB_FLUSH_ALLOWED_NDM_STATES) {3106		NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm state bits set");3107		return -EINVAL;3108	}3109 3110	desc.state = ndm->ndm_state;3111	desc.flags = ndm_flags;3112 3113	if (tb[NDA_NDM_STATE_MASK])3114		desc.state_mask = nla_get_u16(tb[NDA_NDM_STATE_MASK]);3115 3116	if (tb[NDA_NDM_FLAGS_MASK])3117		desc.flags_mask = nla_get_u8(tb[NDA_NDM_FLAGS_MASK]);3118 3119	if (tb[NDA_SRC_VNI])3120		desc.src_vni = cpu_to_be32(nla_get_u32(tb[NDA_SRC_VNI]));3121 3122	if (tb[NDA_NH_ID])3123		desc.nhid = nla_get_u32(tb[NDA_NH_ID]);3124 3125	if (tb[NDA_VNI])3126		desc.vni = cpu_to_be32(nla_get_u32(tb[NDA_VNI]));3127 3128	if (tb[NDA_PORT])3129		desc.port = nla_get_be16(tb[NDA_PORT]);3130 3131	if (tb[NDA_DST]) {3132		union vxlan_addr ip;3133 3134		err = vxlan_nla_get_addr(&ip, tb[NDA_DST]);3135		if (err) {3136			NL_SET_ERR_MSG_ATTR(extack, tb[NDA_DST],3137					    "Unsupported address family");3138			return err;3139		}3140		desc.dst_ip = ip;3141	}3142 3143	vxlan_flush(vxlan, &desc);3144 3145	return 0;3146}3147 3148/* Cleanup timer and forwarding table on shutdown */3149static int vxlan_stop(struct net_device *dev)3150{3151	struct vxlan_dev *vxlan = netdev_priv(dev);3152	struct vxlan_fdb_flush_desc desc = {3153		/* Default entry is deleted at vxlan_uninit. */3154		.ignore_default_entry = true,3155		.state = 0,3156		.state_mask = NUD_PERMANENT | NUD_NOARP,3157	};3158 3159	vxlan_multicast_leave(vxlan);3160 3161	del_timer_sync(&vxlan->age_timer);3162 3163	vxlan_flush(vxlan, &desc);3164	vxlan_sock_release(vxlan);3165 3166	return 0;3167}3168 3169/* Stub, nothing needs to be done. */3170static void vxlan_set_multicast_list(struct net_device *dev)3171{3172}3173 3174static int vxlan_change_mtu(struct net_device *dev, int new_mtu)3175{3176	struct vxlan_dev *vxlan = netdev_priv(dev);3177	struct vxlan_rdst *dst = &vxlan->default_dst;3178	struct net_device *lowerdev = __dev_get_by_index(vxlan->net,3179							 dst->remote_ifindex);3180 3181	/* This check is different than dev->max_mtu, because it looks at3182	 * the lowerdev->mtu, rather than the static dev->max_mtu3183	 */3184	if (lowerdev) {3185		int max_mtu = lowerdev->mtu - vxlan_headroom(vxlan->cfg.flags);3186		if (new_mtu > max_mtu)3187			return -EINVAL;3188	}3189 3190	WRITE_ONCE(dev->mtu, new_mtu);3191	return 0;3192}3193 3194static int vxlan_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)3195{3196	struct vxlan_dev *vxlan = netdev_priv(dev);3197	struct ip_tunnel_info *info = skb_tunnel_info(skb);3198	__be16 sport, dport;3199 3200	sport = udp_flow_src_port(dev_net(dev), skb, vxlan->cfg.port_min,3201				  vxlan->cfg.port_max, true);3202	dport = info->key.tp_dst ? : vxlan->cfg.dst_port;3203 3204	if (ip_tunnel_info_af(info) == AF_INET) {3205		struct vxlan_sock *sock4 = rcu_dereference(vxlan->vn4_sock);3206		struct rtable *rt;3207 3208		if (!sock4)3209			return -EIO;3210 3211		rt = udp_tunnel_dst_lookup(skb, dev, vxlan->net, 0,3212					   &info->key.u.ipv4.src,3213					   &info->key,3214					   sport, dport, info->key.tos,3215					   &info->dst_cache);3216		if (IS_ERR(rt))3217			return PTR_ERR(rt);3218		ip_rt_put(rt);3219	} else {3220#if IS_ENABLED(CONFIG_IPV6)3221		struct vxlan_sock *sock6 = rcu_dereference(vxlan->vn6_sock);3222		struct dst_entry *ndst;3223 3224		if (!sock6)3225			return -EIO;3226 3227		ndst = udp_tunnel6_dst_lookup(skb, dev, vxlan->net, sock6->sock,3228					      0, &info->key.u.ipv6.src,3229					      &info->key,3230					      sport, dport, info->key.tos,3231					      &info->dst_cache);3232		if (IS_ERR(ndst))3233			return PTR_ERR(ndst);3234		dst_release(ndst);3235#else /* !CONFIG_IPV6 */3236		return -EPFNOSUPPORT;3237#endif3238	}3239	info->key.tp_src = sport;3240	info->key.tp_dst = dport;3241	return 0;3242}3243 3244static const struct net_device_ops vxlan_netdev_ether_ops = {3245	.ndo_init		= vxlan_init,3246	.ndo_uninit		= vxlan_uninit,3247	.ndo_open		= vxlan_open,3248	.ndo_stop		= vxlan_stop,3249	.ndo_start_xmit		= vxlan_xmit,3250	.ndo_set_rx_mode	= vxlan_set_multicast_list,3251	.ndo_change_mtu		= vxlan_change_mtu,3252	.ndo_validate_addr	= eth_validate_addr,3253	.ndo_set_mac_address	= eth_mac_addr,3254	.ndo_fdb_add		= vxlan_fdb_add,3255	.ndo_fdb_del		= vxlan_fdb_delete,3256	.ndo_fdb_del_bulk	= vxlan_fdb_delete_bulk,3257	.ndo_fdb_dump		= vxlan_fdb_dump,3258	.ndo_fdb_get		= vxlan_fdb_get,3259	.ndo_mdb_add		= vxlan_mdb_add,3260	.ndo_mdb_del		= vxlan_mdb_del,3261	.ndo_mdb_del_bulk	= vxlan_mdb_del_bulk,3262	.ndo_mdb_dump		= vxlan_mdb_dump,3263	.ndo_mdb_get		= vxlan_mdb_get,3264	.ndo_fill_metadata_dst	= vxlan_fill_metadata_dst,3265};3266 3267static const struct net_device_ops vxlan_netdev_raw_ops = {3268	.ndo_init		= vxlan_init,3269	.ndo_uninit		= vxlan_uninit,3270	.ndo_open		= vxlan_open,3271	.ndo_stop		= vxlan_stop,3272	.ndo_start_xmit		= vxlan_xmit,3273	.ndo_change_mtu		= vxlan_change_mtu,3274	.ndo_fill_metadata_dst	= vxlan_fill_metadata_dst,3275};3276 3277/* Info for udev, that this is a virtual tunnel endpoint */3278static const struct device_type vxlan_type = {3279	.name = "vxlan",3280};3281 3282/* Calls the ndo_udp_tunnel_add of the caller in order to3283 * supply the listening VXLAN udp ports. Callers are expected3284 * to implement the ndo_udp_tunnel_add.3285 */3286static void vxlan_offload_rx_ports(struct net_device *dev, bool push)3287{3288	struct vxlan_sock *vs;3289	struct net *net = dev_net(dev);3290	struct vxlan_net *vn = net_generic(net, vxlan_net_id);3291	unsigned int i;3292 3293	spin_lock(&vn->sock_lock);3294	for (i = 0; i < PORT_HASH_SIZE; ++i) {3295		hlist_for_each_entry_rcu(vs, &vn->sock_list[i], hlist) {3296			unsigned short type;3297 3298			if (vs->flags & VXLAN_F_GPE)3299				type = UDP_TUNNEL_TYPE_VXLAN_GPE;3300			else3301				type = UDP_TUNNEL_TYPE_VXLAN;3302 3303			if (push)3304				udp_tunnel_push_rx_port(dev, vs->sock, type);3305			else3306				udp_tunnel_drop_rx_port(dev, vs->sock, type);3307		}3308	}3309	spin_unlock(&vn->sock_lock);3310}3311 3312/* Initialize the device structure. */3313static void vxlan_setup(struct net_device *dev)3314{3315	struct vxlan_dev *vxlan = netdev_priv(dev);3316	unsigned int h;3317 3318	eth_hw_addr_random(dev);3319	ether_setup(dev);3320 3321	dev->needs_free_netdev = true;3322	SET_NETDEV_DEVTYPE(dev, &vxlan_type);3323 3324	dev->features	|= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST;3325	dev->features   |= NETIF_F_RXCSUM;3326	dev->features   |= NETIF_F_GSO_SOFTWARE;3327 3328	dev->vlan_features = dev->features;3329	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST;3330	dev->hw_features |= NETIF_F_RXCSUM;3331	dev->hw_features |= NETIF_F_GSO_SOFTWARE;3332	netif_keep_dst(dev);3333	dev->priv_flags |= IFF_NO_QUEUE;3334	dev->change_proto_down = true;3335	dev->lltx = true;3336 3337	/* MTU range: 68 - 65535 */3338	dev->min_mtu = ETH_MIN_MTU;3339	dev->max_mtu = ETH_MAX_MTU;3340 3341	dev->pcpu_stat_type = NETDEV_PCPU_STAT_TSTATS;3342	INIT_LIST_HEAD(&vxlan->next);3343 3344	timer_setup(&vxlan->age_timer, vxlan_cleanup, TIMER_DEFERRABLE);3345 3346	vxlan->dev = dev;3347 3348	for (h = 0; h < FDB_HASH_SIZE; ++h) {3349		spin_lock_init(&vxlan->hash_lock[h]);3350		INIT_HLIST_HEAD(&vxlan->fdb_head[h]);3351	}3352}3353 3354static void vxlan_ether_setup(struct net_device *dev)3355{3356	dev->priv_flags &= ~IFF_TX_SKB_SHARING;3357	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;3358	dev->netdev_ops = &vxlan_netdev_ether_ops;3359}3360 3361static void vxlan_raw_setup(struct net_device *dev)3362{3363	dev->header_ops = NULL;3364	dev->type = ARPHRD_NONE;3365	dev->hard_header_len = 0;3366	dev->addr_len = 0;3367	dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;3368	dev->netdev_ops = &vxlan_netdev_raw_ops;3369}3370 3371static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {3372	[IFLA_VXLAN_UNSPEC]     = { .strict_start_type = IFLA_VXLAN_LOCALBYPASS },3373	[IFLA_VXLAN_ID]		= { .type = NLA_U32 },3374	[IFLA_VXLAN_GROUP]	= { .len = sizeof_field(struct iphdr, daddr) },3375	[IFLA_VXLAN_GROUP6]	= { .len = sizeof(struct in6_addr) },3376	[IFLA_VXLAN_LINK]	= { .type = NLA_U32 },3377	[IFLA_VXLAN_LOCAL]	= { .len = sizeof_field(struct iphdr, saddr) },3378	[IFLA_VXLAN_LOCAL6]	= { .len = sizeof(struct in6_addr) },3379	[IFLA_VXLAN_TOS]	= { .type = NLA_U8 },3380	[IFLA_VXLAN_TTL]	= { .type = NLA_U8 },3381	[IFLA_VXLAN_LABEL]	= { .type = NLA_U32 },3382	[IFLA_VXLAN_LEARNING]	= { .type = NLA_U8 },3383	[IFLA_VXLAN_AGEING]	= { .type = NLA_U32 },3384	[IFLA_VXLAN_LIMIT]	= { .type = NLA_U32 },3385	[IFLA_VXLAN_PORT_RANGE] = { .len  = sizeof(struct ifla_vxlan_port_range) },3386	[IFLA_VXLAN_PROXY]	= { .type = NLA_U8 },3387	[IFLA_VXLAN_RSC]	= { .type = NLA_U8 },3388	[IFLA_VXLAN_L2MISS]	= { .type = NLA_U8 },3389	[IFLA_VXLAN_L3MISS]	= { .type = NLA_U8 },3390	[IFLA_VXLAN_COLLECT_METADATA]	= { .type = NLA_U8 },3391	[IFLA_VXLAN_PORT]	= { .type = NLA_U16 },3392	[IFLA_VXLAN_UDP_CSUM]	= { .type = NLA_U8 },3393	[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]	= { .type = NLA_U8 },3394	[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]	= { .type = NLA_U8 },3395	[IFLA_VXLAN_REMCSUM_TX]	= { .type = NLA_U8 },3396	[IFLA_VXLAN_REMCSUM_RX]	= { .type = NLA_U8 },3397	[IFLA_VXLAN_GBP]	= { .type = NLA_FLAG, },3398	[IFLA_VXLAN_GPE]	= { .type = NLA_FLAG, },3399	[IFLA_VXLAN_REMCSUM_NOPARTIAL]	= { .type = NLA_FLAG },3400	[IFLA_VXLAN_TTL_INHERIT]	= { .type = NLA_FLAG },3401	[IFLA_VXLAN_DF]		= { .type = NLA_U8 },3402	[IFLA_VXLAN_VNIFILTER]	= { .type = NLA_U8 },3403	[IFLA_VXLAN_LOCALBYPASS]	= NLA_POLICY_MAX(NLA_U8, 1),3404	[IFLA_VXLAN_LABEL_POLICY]       = NLA_POLICY_MAX(NLA_U32, VXLAN_LABEL_MAX),3405};3406 3407static int vxlan_validate(struct nlattr *tb[], struct nlattr *data[],3408			  struct netlink_ext_ack *extack)3409{3410	if (tb[IFLA_ADDRESS]) {3411		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {3412			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_ADDRESS],3413					    "Provided link layer address is not Ethernet");3414			return -EINVAL;3415		}3416 3417		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {3418			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_ADDRESS],3419					    "Provided Ethernet address is not unicast");3420			return -EADDRNOTAVAIL;3421		}3422	}3423 3424	if (tb[IFLA_MTU]) {3425		u32 mtu = nla_get_u32(tb[IFLA_MTU]);3426 3427		if (mtu < ETH_MIN_MTU || mtu > ETH_MAX_MTU) {3428			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_MTU],3429					    "MTU must be between 68 and 65535");3430			return -EINVAL;3431		}3432	}3433 3434	if (!data) {3435		NL_SET_ERR_MSG(extack,3436			       "Required attributes not provided to perform the operation");3437		return -EINVAL;3438	}3439 3440	if (data[IFLA_VXLAN_ID]) {3441		u32 id = nla_get_u32(data[IFLA_VXLAN_ID]);3442 3443		if (id >= VXLAN_N_VID) {3444			NL_SET_ERR_MSG_ATTR(extack, data[IFLA_VXLAN_ID],3445					    "VXLAN ID must be lower than 16777216");3446			return -ERANGE;3447		}3448	}3449 3450	if (data[IFLA_VXLAN_PORT_RANGE]) {3451		const struct ifla_vxlan_port_range *p3452			= nla_data(data[IFLA_VXLAN_PORT_RANGE]);3453 3454		if (ntohs(p->high) < ntohs(p->low)) {3455			NL_SET_ERR_MSG_ATTR(extack, data[IFLA_VXLAN_PORT_RANGE],3456					    "Invalid source port range");3457			return -EINVAL;3458		}3459	}3460 3461	if (data[IFLA_VXLAN_DF]) {3462		enum ifla_vxlan_df df = nla_get_u8(data[IFLA_VXLAN_DF]);3463 3464		if (df < 0 || df > VXLAN_DF_MAX) {3465			NL_SET_ERR_MSG_ATTR(extack, data[IFLA_VXLAN_DF],3466					    "Invalid DF attribute");3467			return -EINVAL;3468		}3469	}3470 3471	return 0;3472}3473 3474static void vxlan_get_drvinfo(struct net_device *netdev,3475			      struct ethtool_drvinfo *drvinfo)3476{3477	strscpy(drvinfo->version, VXLAN_VERSION, sizeof(drvinfo->version));3478	strscpy(drvinfo->driver, "vxlan", sizeof(drvinfo->driver));3479}3480 3481static int vxlan_get_link_ksettings(struct net_device *dev,3482				    struct ethtool_link_ksettings *cmd)3483{3484	struct vxlan_dev *vxlan = netdev_priv(dev);3485	struct vxlan_rdst *dst = &vxlan->default_dst;3486	struct net_device *lowerdev = __dev_get_by_index(vxlan->net,3487							 dst->remote_ifindex);3488 3489	if (!lowerdev) {3490		cmd->base.duplex = DUPLEX_UNKNOWN;3491		cmd->base.port = PORT_OTHER;3492		cmd->base.speed = SPEED_UNKNOWN;3493 3494		return 0;3495	}3496 3497	return __ethtool_get_link_ksettings(lowerdev, cmd);3498}3499 3500static const struct ethtool_ops vxlan_ethtool_ops = {3501	.get_drvinfo		= vxlan_get_drvinfo,3502	.get_link		= ethtool_op_get_link,3503	.get_link_ksettings	= vxlan_get_link_ksettings,3504};3505 3506static struct socket *vxlan_create_sock(struct net *net, bool ipv6,3507					__be16 port, u32 flags, int ifindex)3508{3509	struct socket *sock;3510	struct udp_port_cfg udp_conf;3511	int err;3512 3513	memset(&udp_conf, 0, sizeof(udp_conf));3514 3515	if (ipv6) {3516		udp_conf.family = AF_INET6;3517		udp_conf.use_udp6_rx_checksums =3518		    !(flags & VXLAN_F_UDP_ZERO_CSUM6_RX);3519		udp_conf.ipv6_v6only = 1;3520	} else {3521		udp_conf.family = AF_INET;3522	}3523 3524	udp_conf.local_udp_port = port;3525	udp_conf.bind_ifindex = ifindex;3526 3527	/* Open UDP socket */3528	err = udp_sock_create(net, &udp_conf, &sock);3529	if (err < 0)3530		return ERR_PTR(err);3531 3532	udp_allow_gso(sock->sk);3533	return sock;3534}3535 3536/* Create new listen socket if needed */3537static struct vxlan_sock *vxlan_socket_create(struct net *net, bool ipv6,3538					      __be16 port, u32 flags,3539					      int ifindex)3540{3541	struct vxlan_net *vn = net_generic(net, vxlan_net_id);3542	struct vxlan_sock *vs;3543	struct socket *sock;3544	unsigned int h;3545	struct udp_tunnel_sock_cfg tunnel_cfg;3546 3547	vs = kzalloc(sizeof(*vs), GFP_KERNEL);3548	if (!vs)3549		return ERR_PTR(-ENOMEM);3550 3551	for (h = 0; h < VNI_HASH_SIZE; ++h)3552		INIT_HLIST_HEAD(&vs->vni_list[h]);3553 3554	sock = vxlan_create_sock(net, ipv6, port, flags, ifindex);3555	if (IS_ERR(sock)) {3556		kfree(vs);3557		return ERR_CAST(sock);3558	}3559 3560	vs->sock = sock;3561	refcount_set(&vs->refcnt, 1);3562	vs->flags = (flags & VXLAN_F_RCV_FLAGS);3563 3564	spin_lock(&vn->sock_lock);3565	hlist_add_head_rcu(&vs->hlist, vs_head(net, port));3566	udp_tunnel_notify_add_rx_port(sock,3567				      (vs->flags & VXLAN_F_GPE) ?3568				      UDP_TUNNEL_TYPE_VXLAN_GPE :3569				      UDP_TUNNEL_TYPE_VXLAN);3570	spin_unlock(&vn->sock_lock);3571 3572	/* Mark socket as an encapsulation socket. */3573	memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));3574	tunnel_cfg.sk_user_data = vs;3575	tunnel_cfg.encap_type = 1;3576	tunnel_cfg.encap_rcv = vxlan_rcv;3577	tunnel_cfg.encap_err_lookup = vxlan_err_lookup;3578	tunnel_cfg.encap_destroy = NULL;3579	if (vs->flags & VXLAN_F_GPE) {3580		tunnel_cfg.gro_receive = vxlan_gpe_gro_receive;3581		tunnel_cfg.gro_complete = vxlan_gpe_gro_complete;3582	} else {3583		tunnel_cfg.gro_receive = vxlan_gro_receive;3584		tunnel_cfg.gro_complete = vxlan_gro_complete;3585	}3586 3587	setup_udp_tunnel_sock(net, sock, &tunnel_cfg);3588 3589	return vs;3590}3591 3592static int __vxlan_sock_add(struct vxlan_dev *vxlan, bool ipv6)3593{3594	struct vxlan_net *vn = net_generic(vxlan->net, vxlan_net_id);3595	bool metadata = vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA;3596	struct vxlan_sock *vs = NULL;3597	struct vxlan_dev_node *node;3598	int l3mdev_index = 0;3599 3600	if (vxlan->cfg.remote_ifindex)3601		l3mdev_index = l3mdev_master_upper_ifindex_by_index(3602			vxlan->net, vxlan->cfg.remote_ifindex);3603 3604	if (!vxlan->cfg.no_share) {3605		spin_lock(&vn->sock_lock);3606		vs = vxlan_find_sock(vxlan->net, ipv6 ? AF_INET6 : AF_INET,3607				     vxlan->cfg.dst_port, vxlan->cfg.flags,3608				     l3mdev_index);3609		if (vs && !refcount_inc_not_zero(&vs->refcnt)) {3610			spin_unlock(&vn->sock_lock);3611			return -EBUSY;3612		}3613		spin_unlock(&vn->sock_lock);3614	}3615	if (!vs)3616		vs = vxlan_socket_create(vxlan->net, ipv6,3617					 vxlan->cfg.dst_port, vxlan->cfg.flags,3618					 l3mdev_index);3619	if (IS_ERR(vs))3620		return PTR_ERR(vs);3621#if IS_ENABLED(CONFIG_IPV6)3622	if (ipv6) {3623		rcu_assign_pointer(vxlan->vn6_sock, vs);3624		node = &vxlan->hlist6;3625	} else3626#endif3627	{3628		rcu_assign_pointer(vxlan->vn4_sock, vs);3629		node = &vxlan->hlist4;3630	}3631 3632	if (metadata && (vxlan->cfg.flags & VXLAN_F_VNIFILTER))3633		vxlan_vs_add_vnigrp(vxlan, vs, ipv6);3634	else3635		vxlan_vs_add_dev(vs, vxlan, node);3636 3637	return 0;3638}3639 3640static int vxlan_sock_add(struct vxlan_dev *vxlan)3641{3642	bool metadata = vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA;3643	bool ipv6 = vxlan->cfg.flags & VXLAN_F_IPV6 || metadata;3644	bool ipv4 = !ipv6 || metadata;3645	int ret = 0;3646 3647	RCU_INIT_POINTER(vxlan->vn4_sock, NULL);3648#if IS_ENABLED(CONFIG_IPV6)3649	RCU_INIT_POINTER(vxlan->vn6_sock, NULL);3650	if (ipv6) {3651		ret = __vxlan_sock_add(vxlan, true);3652		if (ret < 0 && ret != -EAFNOSUPPORT)3653			ipv4 = false;3654	}3655#endif3656	if (ipv4)3657		ret = __vxlan_sock_add(vxlan, false);3658	if (ret < 0)3659		vxlan_sock_release(vxlan);3660	return ret;3661}3662 3663int vxlan_vni_in_use(struct net *src_net, struct vxlan_dev *vxlan,3664		     struct vxlan_config *conf, __be32 vni)3665{3666	struct vxlan_net *vn = net_generic(src_net, vxlan_net_id);3667	struct vxlan_dev *tmp;3668 3669	list_for_each_entry(tmp, &vn->vxlan_list, next) {3670		if (tmp == vxlan)3671			continue;3672		if (tmp->cfg.flags & VXLAN_F_VNIFILTER) {3673			if (!vxlan_vnifilter_lookup(tmp, vni))3674				continue;3675		} else if (tmp->cfg.vni != vni) {3676			continue;3677		}3678		if (tmp->cfg.dst_port != conf->dst_port)3679			continue;3680		if ((tmp->cfg.flags & (VXLAN_F_RCV_FLAGS | VXLAN_F_IPV6)) !=3681		    (conf->flags & (VXLAN_F_RCV_FLAGS | VXLAN_F_IPV6)))3682			continue;3683 3684		if ((conf->flags & VXLAN_F_IPV6_LINKLOCAL) &&3685		    tmp->cfg.remote_ifindex != conf->remote_ifindex)3686			continue;3687 3688		return -EEXIST;3689	}3690 3691	return 0;3692}3693 3694static int vxlan_config_validate(struct net *src_net, struct vxlan_config *conf,3695				 struct net_device **lower,3696				 struct vxlan_dev *old,3697				 struct netlink_ext_ack *extack)3698{3699	bool use_ipv6 = false;3700 3701	if (conf->flags & VXLAN_F_GPE) {3702		/* For now, allow GPE only together with3703		 * COLLECT_METADATA. This can be relaxed later; in such3704		 * case, the other side of the PtP link will have to be3705		 * provided.3706		 */3707		if ((conf->flags & ~VXLAN_F_ALLOWED_GPE) ||3708		    !(conf->flags & VXLAN_F_COLLECT_METADATA)) {3709			NL_SET_ERR_MSG(extack,3710				       "VXLAN GPE does not support this combination of attributes");3711			return -EINVAL;3712		}3713	}3714 3715	if (!conf->remote_ip.sa.sa_family && !conf->saddr.sa.sa_family) {3716		/* Unless IPv6 is explicitly requested, assume IPv4 */3717		conf->remote_ip.sa.sa_family = AF_INET;3718		conf->saddr.sa.sa_family = AF_INET;3719	} else if (!conf->remote_ip.sa.sa_family) {3720		conf->remote_ip.sa.sa_family = conf->saddr.sa.sa_family;3721	} else if (!conf->saddr.sa.sa_family) {3722		conf->saddr.sa.sa_family = conf->remote_ip.sa.sa_family;3723	}3724 3725	if (conf->saddr.sa.sa_family != conf->remote_ip.sa.sa_family) {3726		NL_SET_ERR_MSG(extack,3727			       "Local and remote address must be from the same family");3728		return -EINVAL;3729	}3730 3731	if (vxlan_addr_multicast(&conf->saddr)) {3732		NL_SET_ERR_MSG(extack, "Local address cannot be multicast");3733		return -EINVAL;3734	}3735 3736	if (conf->saddr.sa.sa_family == AF_INET6) {3737		if (!IS_ENABLED(CONFIG_IPV6)) {3738			NL_SET_ERR_MSG(extack,3739				       "IPv6 support not enabled in the kernel");3740			return -EPFNOSUPPORT;3741		}3742		use_ipv6 = true;3743		conf->flags |= VXLAN_F_IPV6;3744 3745		if (!(conf->flags & VXLAN_F_COLLECT_METADATA)) {3746			int local_type =3747				ipv6_addr_type(&conf->saddr.sin6.sin6_addr);3748			int remote_type =3749				ipv6_addr_type(&conf->remote_ip.sin6.sin6_addr);3750 3751			if (local_type & IPV6_ADDR_LINKLOCAL) {3752				if (!(remote_type & IPV6_ADDR_LINKLOCAL) &&3753				    (remote_type != IPV6_ADDR_ANY)) {3754					NL_SET_ERR_MSG(extack,3755						       "Invalid combination of local and remote address scopes");3756					return -EINVAL;3757				}3758 3759				conf->flags |= VXLAN_F_IPV6_LINKLOCAL;3760			} else {3761				if (remote_type ==3762				    (IPV6_ADDR_UNICAST | IPV6_ADDR_LINKLOCAL)) {3763					NL_SET_ERR_MSG(extack,3764						       "Invalid combination of local and remote address scopes");3765					return -EINVAL;3766				}3767 3768				conf->flags &= ~VXLAN_F_IPV6_LINKLOCAL;3769			}3770		}3771	}3772 3773	if (conf->label && !use_ipv6) {3774		NL_SET_ERR_MSG(extack,3775			       "Label attribute only applies to IPv6 VXLAN devices");3776		return -EINVAL;3777	}3778 3779	if (conf->label_policy && !use_ipv6) {3780		NL_SET_ERR_MSG(extack,3781			       "Label policy only applies to IPv6 VXLAN devices");3782		return -EINVAL;3783	}3784 3785	if (conf->remote_ifindex) {3786		struct net_device *lowerdev;3787 3788		lowerdev = __dev_get_by_index(src_net, conf->remote_ifindex);3789		if (!lowerdev) {3790			NL_SET_ERR_MSG(extack,3791				       "Invalid local interface, device not found");3792			return -ENODEV;3793		}3794 3795#if IS_ENABLED(CONFIG_IPV6)3796		if (use_ipv6) {3797			struct inet6_dev *idev = __in6_dev_get(lowerdev);3798 3799			if (idev && idev->cnf.disable_ipv6) {3800				NL_SET_ERR_MSG(extack,3801					       "IPv6 support disabled by administrator");3802				return -EPERM;3803			}3804		}3805#endif3806 3807		*lower = lowerdev;3808	} else {3809		if (vxlan_addr_multicast(&conf->remote_ip)) {3810			NL_SET_ERR_MSG(extack,3811				       "Local interface required for multicast remote destination");3812 3813			return -EINVAL;3814		}3815 3816#if IS_ENABLED(CONFIG_IPV6)3817		if (conf->flags & VXLAN_F_IPV6_LINKLOCAL) {3818			NL_SET_ERR_MSG(extack,3819				       "Local interface required for link-local local/remote addresses");3820			return -EINVAL;3821		}3822#endif3823 3824		*lower = NULL;3825	}3826 3827	if (!conf->dst_port) {3828		if (conf->flags & VXLAN_F_GPE)3829			conf->dst_port = htons(IANA_VXLAN_GPE_UDP_PORT);3830		else3831			conf->dst_port = htons(vxlan_port);3832	}3833 3834	if (!conf->age_interval)3835		conf->age_interval = FDB_AGE_DEFAULT;3836 3837	if (vxlan_vni_in_use(src_net, old, conf, conf->vni)) {3838		NL_SET_ERR_MSG(extack,3839			       "A VXLAN device with the specified VNI already exists");3840		return -EEXIST;3841	}3842 3843	return 0;3844}3845 3846static void vxlan_config_apply(struct net_device *dev,3847			       struct vxlan_config *conf,3848			       struct net_device *lowerdev,3849			       struct net *src_net,3850			       bool changelink)3851{3852	struct vxlan_dev *vxlan = netdev_priv(dev);3853	struct vxlan_rdst *dst = &vxlan->default_dst;3854	unsigned short needed_headroom = ETH_HLEN;3855	int max_mtu = ETH_MAX_MTU;3856	u32 flags = conf->flags;3857 3858	if (!changelink) {3859		if (flags & VXLAN_F_GPE)3860			vxlan_raw_setup(dev);3861		else3862			vxlan_ether_setup(dev);3863 3864		if (conf->mtu)3865			dev->mtu = conf->mtu;3866 3867		vxlan->net = src_net;3868	}3869 3870	dst->remote_vni = conf->vni;3871 3872	memcpy(&dst->remote_ip, &conf->remote_ip, sizeof(conf->remote_ip));3873 3874	if (lowerdev) {3875		dst->remote_ifindex = conf->remote_ifindex;3876 3877		netif_inherit_tso_max(dev, lowerdev);3878 3879		needed_headroom = lowerdev->hard_header_len;3880		needed_headroom += lowerdev->needed_headroom;3881 3882		dev->needed_tailroom = lowerdev->needed_tailroom;3883 3884		max_mtu = lowerdev->mtu - vxlan_headroom(flags);3885		if (max_mtu < ETH_MIN_MTU)3886			max_mtu = ETH_MIN_MTU;3887 3888		if (!changelink && !conf->mtu)3889			dev->mtu = max_mtu;3890	}3891 3892	if (dev->mtu > max_mtu)3893		dev->mtu = max_mtu;3894 3895	if (flags & VXLAN_F_COLLECT_METADATA)3896		flags |= VXLAN_F_IPV6;3897	needed_headroom += vxlan_headroom(flags);3898	dev->needed_headroom = needed_headroom;3899 3900	memcpy(&vxlan->cfg, conf, sizeof(*conf));3901}3902 3903static int vxlan_dev_configure(struct net *src_net, struct net_device *dev,3904			       struct vxlan_config *conf, bool changelink,3905			       struct netlink_ext_ack *extack)3906{3907	struct vxlan_dev *vxlan = netdev_priv(dev);3908	struct net_device *lowerdev;3909	int ret;3910 3911	ret = vxlan_config_validate(src_net, conf, &lowerdev, vxlan, extack);3912	if (ret)3913		return ret;3914 3915	vxlan_config_apply(dev, conf, lowerdev, src_net, changelink);3916 3917	return 0;3918}3919 3920static int __vxlan_dev_create(struct net *net, struct net_device *dev,3921			      struct vxlan_config *conf,3922			      struct netlink_ext_ack *extack)3923{3924	struct vxlan_net *vn = net_generic(net, vxlan_net_id);3925	struct vxlan_dev *vxlan = netdev_priv(dev);3926	struct net_device *remote_dev = NULL;3927	struct vxlan_fdb *f = NULL;3928	bool unregister = false;3929	struct vxlan_rdst *dst;3930	int err;3931 3932	dst = &vxlan->default_dst;3933	err = vxlan_dev_configure(net, dev, conf, false, extack);3934	if (err)3935		return err;3936 3937	dev->ethtool_ops = &vxlan_ethtool_ops;3938 3939	/* create an fdb entry for a valid default destination */3940	if (!vxlan_addr_any(&dst->remote_ip)) {3941		err = vxlan_fdb_create(vxlan, all_zeros_mac,3942				       &dst->remote_ip,3943				       NUD_REACHABLE | NUD_PERMANENT,3944				       vxlan->cfg.dst_port,3945				       dst->remote_vni,3946				       dst->remote_vni,3947				       dst->remote_ifindex,3948				       NTF_SELF, 0, &f, extack);3949		if (err)3950			return err;3951	}3952 3953	err = register_netdevice(dev);3954	if (err)3955		goto errout;3956	unregister = true;3957 3958	if (dst->remote_ifindex) {3959		remote_dev = __dev_get_by_index(net, dst->remote_ifindex);3960		if (!remote_dev) {3961			err = -ENODEV;3962			goto errout;3963		}3964 3965		err = netdev_upper_dev_link(remote_dev, dev, extack);3966		if (err)3967			goto errout;3968	}3969 3970	err = rtnl_configure_link(dev, NULL, 0, NULL);3971	if (err < 0)3972		goto unlink;3973 3974	if (f) {3975		vxlan_fdb_insert(vxlan, all_zeros_mac, dst->remote_vni, f);3976 3977		/* notify default fdb entry */3978		err = vxlan_fdb_notify(vxlan, f, first_remote_rtnl(f),3979				       RTM_NEWNEIGH, true, extack);3980		if (err) {3981			vxlan_fdb_destroy(vxlan, f, false, false);3982			if (remote_dev)3983				netdev_upper_dev_unlink(remote_dev, dev);3984			goto unregister;3985		}3986	}3987 3988	list_add(&vxlan->next, &vn->vxlan_list);3989	if (remote_dev)3990		dst->remote_dev = remote_dev;3991	return 0;3992unlink:3993	if (remote_dev)3994		netdev_upper_dev_unlink(remote_dev, dev);3995errout:3996	/* unregister_netdevice() destroys the default FDB entry with deletion3997	 * notification. But the addition notification was not sent yet, so3998	 * destroy the entry by hand here.3999	 */4000	if (f)4001		__vxlan_fdb_free(f);4002unregister:4003	if (unregister)4004		unregister_netdevice(dev);4005	return err;4006}4007 4008/* Set/clear flags based on attribute */4009static int vxlan_nl2flag(struct vxlan_config *conf, struct nlattr *tb[],4010			  int attrtype, unsigned long mask, bool changelink,4011			  bool changelink_supported,4012			  struct netlink_ext_ack *extack)4013{4014	unsigned long flags;4015 4016	if (!tb[attrtype])4017		return 0;4018 4019	if (changelink && !changelink_supported) {4020		vxlan_flag_attr_error(attrtype, extack);4021		return -EOPNOTSUPP;4022	}4023 4024	if (vxlan_policy[attrtype].type == NLA_FLAG)4025		flags = conf->flags | mask;4026	else if (nla_get_u8(tb[attrtype]))4027		flags = conf->flags | mask;4028	else4029		flags = conf->flags & ~mask;4030 4031	conf->flags = flags;4032 4033	return 0;4034}4035 4036static int vxlan_nl2conf(struct nlattr *tb[], struct nlattr *data[],4037			 struct net_device *dev, struct vxlan_config *conf,4038			 bool changelink, struct netlink_ext_ack *extack)4039{4040	struct vxlan_dev *vxlan = netdev_priv(dev);4041	int err = 0;4042 4043	memset(conf, 0, sizeof(*conf));4044 4045	/* if changelink operation, start with old existing cfg */4046	if (changelink)4047		memcpy(conf, &vxlan->cfg, sizeof(*conf));4048 4049	if (data[IFLA_VXLAN_ID]) {4050		__be32 vni = cpu_to_be32(nla_get_u32(data[IFLA_VXLAN_ID]));4051 4052		if (changelink && (vni != conf->vni)) {4053			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_ID], "Cannot change VNI");4054			return -EOPNOTSUPP;4055		}4056		conf->vni = cpu_to_be32(nla_get_u32(data[IFLA_VXLAN_ID]));4057	}4058 4059	if (data[IFLA_VXLAN_GROUP]) {4060		if (changelink && (conf->remote_ip.sa.sa_family != AF_INET)) {4061			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_GROUP], "New group address family does not match old group");4062			return -EOPNOTSUPP;4063		}4064 4065		conf->remote_ip.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_GROUP]);4066		conf->remote_ip.sa.sa_family = AF_INET;4067	} else if (data[IFLA_VXLAN_GROUP6]) {4068		if (!IS_ENABLED(CONFIG_IPV6)) {4069			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_GROUP6], "IPv6 support not enabled in the kernel");4070			return -EPFNOSUPPORT;4071		}4072 4073		if (changelink && (conf->remote_ip.sa.sa_family != AF_INET6)) {4074			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_GROUP6], "New group address family does not match old group");4075			return -EOPNOTSUPP;4076		}4077 4078		conf->remote_ip.sin6.sin6_addr = nla_get_in6_addr(data[IFLA_VXLAN_GROUP6]);4079		conf->remote_ip.sa.sa_family = AF_INET6;4080	}4081 4082	if (data[IFLA_VXLAN_LOCAL]) {4083		if (changelink && (conf->saddr.sa.sa_family != AF_INET)) {4084			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_LOCAL], "New local address family does not match old");4085			return -EOPNOTSUPP;4086		}4087 4088		conf->saddr.sin.sin_addr.s_addr = nla_get_in_addr(data[IFLA_VXLAN_LOCAL]);4089		conf->saddr.sa.sa_family = AF_INET;4090	} else if (data[IFLA_VXLAN_LOCAL6]) {4091		if (!IS_ENABLED(CONFIG_IPV6)) {4092			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_LOCAL6], "IPv6 support not enabled in the kernel");4093			return -EPFNOSUPPORT;4094		}4095 4096		if (changelink && (conf->saddr.sa.sa_family != AF_INET6)) {4097			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_LOCAL6], "New local address family does not match old");4098			return -EOPNOTSUPP;4099		}4100 4101		/* TODO: respect scope id */4102		conf->saddr.sin6.sin6_addr = nla_get_in6_addr(data[IFLA_VXLAN_LOCAL6]);4103		conf->saddr.sa.sa_family = AF_INET6;4104	}4105 4106	if (data[IFLA_VXLAN_LINK])4107		conf->remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]);4108 4109	if (data[IFLA_VXLAN_TOS])4110		conf->tos  = nla_get_u8(data[IFLA_VXLAN_TOS]);4111 4112	if (data[IFLA_VXLAN_TTL])4113		conf->ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);4114 4115	if (data[IFLA_VXLAN_TTL_INHERIT]) {4116		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_TTL_INHERIT,4117				    VXLAN_F_TTL_INHERIT, changelink, false,4118				    extack);4119		if (err)4120			return err;4121 4122	}4123 4124	if (data[IFLA_VXLAN_LABEL])4125		conf->label = nla_get_be32(data[IFLA_VXLAN_LABEL]) &4126			     IPV6_FLOWLABEL_MASK;4127	if (data[IFLA_VXLAN_LABEL_POLICY])4128		conf->label_policy = nla_get_u32(data[IFLA_VXLAN_LABEL_POLICY]);4129 4130	if (data[IFLA_VXLAN_LEARNING]) {4131		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_LEARNING,4132				    VXLAN_F_LEARN, changelink, true,4133				    extack);4134		if (err)4135			return err;4136	} else if (!changelink) {4137		/* default to learn on a new device */4138		conf->flags |= VXLAN_F_LEARN;4139	}4140 4141	if (data[IFLA_VXLAN_AGEING])4142		conf->age_interval = nla_get_u32(data[IFLA_VXLAN_AGEING]);4143 4144	if (data[IFLA_VXLAN_PROXY]) {4145		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_PROXY,4146				    VXLAN_F_PROXY, changelink, false,4147				    extack);4148		if (err)4149			return err;4150	}4151 4152	if (data[IFLA_VXLAN_RSC]) {4153		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_RSC,4154				    VXLAN_F_RSC, changelink, false,4155				    extack);4156		if (err)4157			return err;4158	}4159 4160	if (data[IFLA_VXLAN_L2MISS]) {4161		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_L2MISS,4162				    VXLAN_F_L2MISS, changelink, false,4163				    extack);4164		if (err)4165			return err;4166	}4167 4168	if (data[IFLA_VXLAN_L3MISS]) {4169		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_L3MISS,4170				    VXLAN_F_L3MISS, changelink, false,4171				    extack);4172		if (err)4173			return err;4174	}4175 4176	if (data[IFLA_VXLAN_LIMIT]) {4177		if (changelink) {4178			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_LIMIT],4179					    "Cannot change limit");4180			return -EOPNOTSUPP;4181		}4182		conf->addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);4183	}4184 4185	if (data[IFLA_VXLAN_COLLECT_METADATA]) {4186		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_COLLECT_METADATA,4187				    VXLAN_F_COLLECT_METADATA, changelink, false,4188				    extack);4189		if (err)4190			return err;4191	}4192 4193	if (data[IFLA_VXLAN_PORT_RANGE]) {4194		if (!changelink) {4195			const struct ifla_vxlan_port_range *p4196				= nla_data(data[IFLA_VXLAN_PORT_RANGE]);4197			conf->port_min = ntohs(p->low);4198			conf->port_max = ntohs(p->high);4199		} else {4200			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_PORT_RANGE],4201					    "Cannot change port range");4202			return -EOPNOTSUPP;4203		}4204	}4205 4206	if (data[IFLA_VXLAN_PORT]) {4207		if (changelink) {4208			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_PORT],4209					    "Cannot change port");4210			return -EOPNOTSUPP;4211		}4212		conf->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);4213	}4214 4215	if (data[IFLA_VXLAN_UDP_CSUM]) {4216		if (changelink) {4217			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_VXLAN_UDP_CSUM],4218					    "Cannot change UDP_CSUM flag");4219			return -EOPNOTSUPP;4220		}4221		if (!nla_get_u8(data[IFLA_VXLAN_UDP_CSUM]))4222			conf->flags |= VXLAN_F_UDP_ZERO_CSUM_TX;4223	}4224 4225	if (data[IFLA_VXLAN_LOCALBYPASS]) {4226		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_LOCALBYPASS,4227				    VXLAN_F_LOCALBYPASS, changelink,4228				    true, extack);4229		if (err)4230			return err;4231	} else if (!changelink) {4232		/* default to local bypass on a new device */4233		conf->flags |= VXLAN_F_LOCALBYPASS;4234	}4235 4236	if (data[IFLA_VXLAN_UDP_ZERO_CSUM6_TX]) {4237		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_UDP_ZERO_CSUM6_TX,4238				    VXLAN_F_UDP_ZERO_CSUM6_TX, changelink,4239				    false, extack);4240		if (err)4241			return err;4242	}4243 4244	if (data[IFLA_VXLAN_UDP_ZERO_CSUM6_RX]) {4245		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_UDP_ZERO_CSUM6_RX,4246				    VXLAN_F_UDP_ZERO_CSUM6_RX, changelink,4247				    false, extack);4248		if (err)4249			return err;4250	}4251 4252	if (data[IFLA_VXLAN_REMCSUM_TX]) {4253		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_REMCSUM_TX,4254				    VXLAN_F_REMCSUM_TX, changelink, false,4255				    extack);4256		if (err)4257			return err;4258	}4259 4260	if (data[IFLA_VXLAN_REMCSUM_RX]) {4261		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_REMCSUM_RX,4262				    VXLAN_F_REMCSUM_RX, changelink, false,4263				    extack);4264		if (err)4265			return err;4266	}4267 4268	if (data[IFLA_VXLAN_GBP]) {4269		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_GBP,4270				    VXLAN_F_GBP, changelink, false, extack);4271		if (err)4272			return err;4273	}4274 4275	if (data[IFLA_VXLAN_GPE]) {4276		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_GPE,4277				    VXLAN_F_GPE, changelink, false,4278				    extack);4279		if (err)4280			return err;4281	}4282 4283	if (data[IFLA_VXLAN_REMCSUM_NOPARTIAL]) {4284		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_REMCSUM_NOPARTIAL,4285				    VXLAN_F_REMCSUM_NOPARTIAL, changelink,4286				    false, extack);4287		if (err)4288			return err;4289	}4290 4291	if (tb[IFLA_MTU]) {4292		if (changelink) {4293			NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_MTU],4294					    "Cannot change mtu");4295			return -EOPNOTSUPP;4296		}4297		conf->mtu = nla_get_u32(tb[IFLA_MTU]);4298	}4299 4300	if (data[IFLA_VXLAN_DF])4301		conf->df = nla_get_u8(data[IFLA_VXLAN_DF]);4302 4303	if (data[IFLA_VXLAN_VNIFILTER]) {4304		err = vxlan_nl2flag(conf, data, IFLA_VXLAN_VNIFILTER,4305				    VXLAN_F_VNIFILTER, changelink, false,4306				    extack);4307		if (err)4308			return err;4309 4310		if ((conf->flags & VXLAN_F_VNIFILTER) &&4311		    !(conf->flags & VXLAN_F_COLLECT_METADATA)) {4312			NL_SET_ERR_MSG_ATTR(extack, data[IFLA_VXLAN_VNIFILTER],4313					    "vxlan vnifilter only valid in collect metadata mode");4314			return -EINVAL;4315		}4316	}4317 4318	return 0;4319}4320 4321static int vxlan_newlink(struct net *src_net, struct net_device *dev,4322			 struct nlattr *tb[], struct nlattr *data[],4323			 struct netlink_ext_ack *extack)4324{4325	struct vxlan_config conf;4326	int err;4327 4328	err = vxlan_nl2conf(tb, data, dev, &conf, false, extack);4329	if (err)4330		return err;4331 4332	return __vxlan_dev_create(src_net, dev, &conf, extack);4333}4334 4335static int vxlan_changelink(struct net_device *dev, struct nlattr *tb[],4336			    struct nlattr *data[],4337			    struct netlink_ext_ack *extack)4338{4339	struct vxlan_dev *vxlan = netdev_priv(dev);4340	struct net_device *lowerdev;4341	struct vxlan_config conf;4342	struct vxlan_rdst *dst;4343	int err;4344 4345	dst = &vxlan->default_dst;4346	err = vxlan_nl2conf(tb, data, dev, &conf, true, extack);4347	if (err)4348		return err;4349 4350	err = vxlan_config_validate(vxlan->net, &conf, &lowerdev,4351				    vxlan, extack);4352	if (err)4353		return err;4354 4355	if (dst->remote_dev == lowerdev)4356		lowerdev = NULL;4357 4358	err = netdev_adjacent_change_prepare(dst->remote_dev, lowerdev, dev,4359					     extack);4360	if (err)4361		return err;4362 4363	/* handle default dst entry */4364	if (!vxlan_addr_equal(&conf.remote_ip, &dst->remote_ip)) {4365		u32 hash_index = fdb_head_index(vxlan, all_zeros_mac, conf.vni);4366 4367		spin_lock_bh(&vxlan->hash_lock[hash_index]);4368		if (!vxlan_addr_any(&conf.remote_ip)) {4369			err = vxlan_fdb_update(vxlan, all_zeros_mac,4370					       &conf.remote_ip,4371					       NUD_REACHABLE | NUD_PERMANENT,4372					       NLM_F_APPEND | NLM_F_CREATE,4373					       vxlan->cfg.dst_port,4374					       conf.vni, conf.vni,4375					       conf.remote_ifindex,4376					       NTF_SELF, 0, true, extack);4377			if (err) {4378				spin_unlock_bh(&vxlan->hash_lock[hash_index]);4379				netdev_adjacent_change_abort(dst->remote_dev,4380							     lowerdev, dev);4381				return err;4382			}4383		}4384		if (!vxlan_addr_any(&dst->remote_ip))4385			__vxlan_fdb_delete(vxlan, all_zeros_mac,4386					   dst->remote_ip,4387					   vxlan->cfg.dst_port,4388					   dst->remote_vni,4389					   dst->remote_vni,4390					   dst->remote_ifindex,4391					   true);4392		spin_unlock_bh(&vxlan->hash_lock[hash_index]);4393 4394		/* If vni filtering device, also update fdb entries of4395		 * all vnis that were using default remote ip4396		 */4397		if (vxlan->cfg.flags & VXLAN_F_VNIFILTER) {4398			err = vxlan_vnilist_update_group(vxlan, &dst->remote_ip,4399							 &conf.remote_ip, extack);4400			if (err) {4401				netdev_adjacent_change_abort(dst->remote_dev,4402							     lowerdev, dev);4403				return err;4404			}4405		}4406	}4407 4408	if (conf.age_interval != vxlan->cfg.age_interval)4409		mod_timer(&vxlan->age_timer, jiffies);4410 4411	netdev_adjacent_change_commit(dst->remote_dev, lowerdev, dev);4412	if (lowerdev && lowerdev != dst->remote_dev)4413		dst->remote_dev = lowerdev;4414	vxlan_config_apply(dev, &conf, lowerdev, vxlan->net, true);4415	return 0;4416}4417 4418static void vxlan_dellink(struct net_device *dev, struct list_head *head)4419{4420	struct vxlan_dev *vxlan = netdev_priv(dev);4421	struct vxlan_fdb_flush_desc desc = {4422		/* Default entry is deleted at vxlan_uninit. */4423		.ignore_default_entry = true,4424	};4425 4426	vxlan_flush(vxlan, &desc);4427 4428	list_del(&vxlan->next);4429	unregister_netdevice_queue(dev, head);4430	if (vxlan->default_dst.remote_dev)4431		netdev_upper_dev_unlink(vxlan->default_dst.remote_dev, dev);4432}4433 4434static size_t vxlan_get_size(const struct net_device *dev)4435{4436	return nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_ID */4437		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */4438		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LINK */4439		nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */4440		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TTL */4441		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TTL_INHERIT */4442		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_TOS */4443		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_DF */4444		nla_total_size(sizeof(__be32)) + /* IFLA_VXLAN_LABEL */4445		nla_total_size(sizeof(__u32)) +  /* IFLA_VXLAN_LABEL_POLICY */4446		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_LEARNING */4447		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_PROXY */4448		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_RSC */4449		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_L2MISS */4450		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_L3MISS */4451		nla_total_size(sizeof(__u8)) +	/* IFLA_VXLAN_COLLECT_METADATA */4452		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_AGEING */4453		nla_total_size(sizeof(__u32)) +	/* IFLA_VXLAN_LIMIT */4454		nla_total_size(sizeof(__be16)) + /* IFLA_VXLAN_PORT */4455		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_CSUM */4456		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_ZERO_CSUM6_TX */4457		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_UDP_ZERO_CSUM6_RX */4458		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_TX */4459		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_REMCSUM_RX */4460		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_LOCALBYPASS */4461		/* IFLA_VXLAN_PORT_RANGE */4462		nla_total_size(sizeof(struct ifla_vxlan_port_range)) +4463		nla_total_size(0) + /* IFLA_VXLAN_GBP */4464		nla_total_size(0) + /* IFLA_VXLAN_GPE */4465		nla_total_size(0) + /* IFLA_VXLAN_REMCSUM_NOPARTIAL */4466		nla_total_size(sizeof(__u8)) + /* IFLA_VXLAN_VNIFILTER */4467		0;4468}4469 4470static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)4471{4472	const struct vxlan_dev *vxlan = netdev_priv(dev);4473	const struct vxlan_rdst *dst = &vxlan->default_dst;4474	struct ifla_vxlan_port_range ports = {4475		.low =  htons(vxlan->cfg.port_min),4476		.high = htons(vxlan->cfg.port_max),4477	};4478 4479	if (nla_put_u32(skb, IFLA_VXLAN_ID, be32_to_cpu(dst->remote_vni)))4480		goto nla_put_failure;4481 4482	if (!vxlan_addr_any(&dst->remote_ip)) {4483		if (dst->remote_ip.sa.sa_family == AF_INET) {4484			if (nla_put_in_addr(skb, IFLA_VXLAN_GROUP,4485					    dst->remote_ip.sin.sin_addr.s_addr))4486				goto nla_put_failure;4487#if IS_ENABLED(CONFIG_IPV6)4488		} else {4489			if (nla_put_in6_addr(skb, IFLA_VXLAN_GROUP6,4490					     &dst->remote_ip.sin6.sin6_addr))4491				goto nla_put_failure;4492#endif4493		}4494	}4495 4496	if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))4497		goto nla_put_failure;4498 4499	if (!vxlan_addr_any(&vxlan->cfg.saddr)) {4500		if (vxlan->cfg.saddr.sa.sa_family == AF_INET) {4501			if (nla_put_in_addr(skb, IFLA_VXLAN_LOCAL,4502					    vxlan->cfg.saddr.sin.sin_addr.s_addr))4503				goto nla_put_failure;4504#if IS_ENABLED(CONFIG_IPV6)4505		} else {4506			if (nla_put_in6_addr(skb, IFLA_VXLAN_LOCAL6,4507					     &vxlan->cfg.saddr.sin6.sin6_addr))4508				goto nla_put_failure;4509#endif4510		}4511	}4512 4513	if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->cfg.ttl) ||4514	    nla_put_u8(skb, IFLA_VXLAN_TTL_INHERIT,4515		       !!(vxlan->cfg.flags & VXLAN_F_TTL_INHERIT)) ||4516	    nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->cfg.tos) ||4517	    nla_put_u8(skb, IFLA_VXLAN_DF, vxlan->cfg.df) ||4518	    nla_put_be32(skb, IFLA_VXLAN_LABEL, vxlan->cfg.label) ||4519	    nla_put_u32(skb, IFLA_VXLAN_LABEL_POLICY, vxlan->cfg.label_policy) ||4520	    nla_put_u8(skb, IFLA_VXLAN_LEARNING,4521		       !!(vxlan->cfg.flags & VXLAN_F_LEARN)) ||4522	    nla_put_u8(skb, IFLA_VXLAN_PROXY,4523		       !!(vxlan->cfg.flags & VXLAN_F_PROXY)) ||4524	    nla_put_u8(skb, IFLA_VXLAN_RSC,4525		       !!(vxlan->cfg.flags & VXLAN_F_RSC)) ||4526	    nla_put_u8(skb, IFLA_VXLAN_L2MISS,4527		       !!(vxlan->cfg.flags & VXLAN_F_L2MISS)) ||4528	    nla_put_u8(skb, IFLA_VXLAN_L3MISS,4529		       !!(vxlan->cfg.flags & VXLAN_F_L3MISS)) ||4530	    nla_put_u8(skb, IFLA_VXLAN_COLLECT_METADATA,4531		       !!(vxlan->cfg.flags & VXLAN_F_COLLECT_METADATA)) ||4532	    nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->cfg.age_interval) ||4533	    nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->cfg.addrmax) ||4534	    nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->cfg.dst_port) ||4535	    nla_put_u8(skb, IFLA_VXLAN_UDP_CSUM,4536		       !(vxlan->cfg.flags & VXLAN_F_UDP_ZERO_CSUM_TX)) ||4537	    nla_put_u8(skb, IFLA_VXLAN_UDP_ZERO_CSUM6_TX,4538		       !!(vxlan->cfg.flags & VXLAN_F_UDP_ZERO_CSUM6_TX)) ||4539	    nla_put_u8(skb, IFLA_VXLAN_UDP_ZERO_CSUM6_RX,4540		       !!(vxlan->cfg.flags & VXLAN_F_UDP_ZERO_CSUM6_RX)) ||4541	    nla_put_u8(skb, IFLA_VXLAN_REMCSUM_TX,4542		       !!(vxlan->cfg.flags & VXLAN_F_REMCSUM_TX)) ||4543	    nla_put_u8(skb, IFLA_VXLAN_REMCSUM_RX,4544		       !!(vxlan->cfg.flags & VXLAN_F_REMCSUM_RX)) ||4545	    nla_put_u8(skb, IFLA_VXLAN_LOCALBYPASS,4546		       !!(vxlan->cfg.flags & VXLAN_F_LOCALBYPASS)))4547		goto nla_put_failure;4548 4549	if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))4550		goto nla_put_failure;4551 4552	if (vxlan->cfg.flags & VXLAN_F_GBP &&4553	    nla_put_flag(skb, IFLA_VXLAN_GBP))4554		goto nla_put_failure;4555 4556	if (vxlan->cfg.flags & VXLAN_F_GPE &&4557	    nla_put_flag(skb, IFLA_VXLAN_GPE))4558		goto nla_put_failure;4559 4560	if (vxlan->cfg.flags & VXLAN_F_REMCSUM_NOPARTIAL &&4561	    nla_put_flag(skb, IFLA_VXLAN_REMCSUM_NOPARTIAL))4562		goto nla_put_failure;4563 4564	if (vxlan->cfg.flags & VXLAN_F_VNIFILTER &&4565	    nla_put_u8(skb, IFLA_VXLAN_VNIFILTER,4566		       !!(vxlan->cfg.flags & VXLAN_F_VNIFILTER)))4567		goto nla_put_failure;4568 4569	return 0;4570 4571nla_put_failure:4572	return -EMSGSIZE;4573}4574 4575static struct net *vxlan_get_link_net(const struct net_device *dev)4576{4577	struct vxlan_dev *vxlan = netdev_priv(dev);4578 4579	return READ_ONCE(vxlan->net);4580}4581 4582static struct rtnl_link_ops vxlan_link_ops __read_mostly = {4583	.kind		= "vxlan",4584	.maxtype	= IFLA_VXLAN_MAX,4585	.policy		= vxlan_policy,4586	.priv_size	= sizeof(struct vxlan_dev),4587	.setup		= vxlan_setup,4588	.validate	= vxlan_validate,4589	.newlink	= vxlan_newlink,4590	.changelink	= vxlan_changelink,4591	.dellink	= vxlan_dellink,4592	.get_size	= vxlan_get_size,4593	.fill_info	= vxlan_fill_info,4594	.get_link_net	= vxlan_get_link_net,4595};4596 4597struct net_device *vxlan_dev_create(struct net *net, const char *name,4598				    u8 name_assign_type,4599				    struct vxlan_config *conf)4600{4601	struct nlattr *tb[IFLA_MAX + 1];4602	struct net_device *dev;4603	int err;4604 4605	memset(&tb, 0, sizeof(tb));4606 4607	dev = rtnl_create_link(net, name, name_assign_type,4608			       &vxlan_link_ops, tb, NULL);4609	if (IS_ERR(dev))4610		return dev;4611 4612	err = __vxlan_dev_create(net, dev, conf, NULL);4613	if (err < 0) {4614		free_netdev(dev);4615		return ERR_PTR(err);4616	}4617 4618	err = rtnl_configure_link(dev, NULL, 0, NULL);4619	if (err < 0) {4620		LIST_HEAD(list_kill);4621 4622		vxlan_dellink(dev, &list_kill);4623		unregister_netdevice_many(&list_kill);4624		return ERR_PTR(err);4625	}4626 4627	return dev;4628}4629EXPORT_SYMBOL_GPL(vxlan_dev_create);4630 4631static void vxlan_handle_lowerdev_unregister(struct vxlan_net *vn,4632					     struct net_device *dev)4633{4634	struct vxlan_dev *vxlan, *next;4635	LIST_HEAD(list_kill);4636 4637	list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next) {4638		struct vxlan_rdst *dst = &vxlan->default_dst;4639 4640		/* In case we created vxlan device with carrier4641		 * and we loose the carrier due to module unload4642		 * we also need to remove vxlan device. In other4643		 * cases, it's not necessary and remote_ifindex4644		 * is 0 here, so no matches.4645		 */4646		if (dst->remote_ifindex == dev->ifindex)4647			vxlan_dellink(vxlan->dev, &list_kill);4648	}4649 4650	unregister_netdevice_many(&list_kill);4651}4652 4653static int vxlan_netdevice_event(struct notifier_block *unused,4654				 unsigned long event, void *ptr)4655{4656	struct net_device *dev = netdev_notifier_info_to_dev(ptr);4657	struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);4658 4659	if (event == NETDEV_UNREGISTER)4660		vxlan_handle_lowerdev_unregister(vn, dev);4661	else if (event == NETDEV_UDP_TUNNEL_PUSH_INFO)4662		vxlan_offload_rx_ports(dev, true);4663	else if (event == NETDEV_UDP_TUNNEL_DROP_INFO)4664		vxlan_offload_rx_ports(dev, false);4665 4666	return NOTIFY_DONE;4667}4668 4669static struct notifier_block vxlan_notifier_block __read_mostly = {4670	.notifier_call = vxlan_netdevice_event,4671};4672 4673static void4674vxlan_fdb_offloaded_set(struct net_device *dev,4675			struct switchdev_notifier_vxlan_fdb_info *fdb_info)4676{4677	struct vxlan_dev *vxlan = netdev_priv(dev);4678	struct vxlan_rdst *rdst;4679	struct vxlan_fdb *f;4680	u32 hash_index;4681 4682	hash_index = fdb_head_index(vxlan, fdb_info->eth_addr, fdb_info->vni);4683 4684	spin_lock_bh(&vxlan->hash_lock[hash_index]);4685 4686	f = vxlan_find_mac(vxlan, fdb_info->eth_addr, fdb_info->vni);4687	if (!f)4688		goto out;4689 4690	rdst = vxlan_fdb_find_rdst(f, &fdb_info->remote_ip,4691				   fdb_info->remote_port,4692				   fdb_info->remote_vni,4693				   fdb_info->remote_ifindex);4694	if (!rdst)4695		goto out;4696 4697	rdst->offloaded = fdb_info->offloaded;4698 4699out:4700	spin_unlock_bh(&vxlan->hash_lock[hash_index]);4701}4702 4703static int4704vxlan_fdb_external_learn_add(struct net_device *dev,4705			     struct switchdev_notifier_vxlan_fdb_info *fdb_info)4706{4707	struct vxlan_dev *vxlan = netdev_priv(dev);4708	struct netlink_ext_ack *extack;4709	u32 hash_index;4710	int err;4711 4712	hash_index = fdb_head_index(vxlan, fdb_info->eth_addr, fdb_info->vni);4713	extack = switchdev_notifier_info_to_extack(&fdb_info->info);4714 4715	spin_lock_bh(&vxlan->hash_lock[hash_index]);4716	err = vxlan_fdb_update(vxlan, fdb_info->eth_addr, &fdb_info->remote_ip,4717			       NUD_REACHABLE,4718			       NLM_F_CREATE | NLM_F_REPLACE,4719			       fdb_info->remote_port,4720			       fdb_info->vni,4721			       fdb_info->remote_vni,4722			       fdb_info->remote_ifindex,4723			       NTF_USE | NTF_SELF | NTF_EXT_LEARNED,4724			       0, false, extack);4725	spin_unlock_bh(&vxlan->hash_lock[hash_index]);4726 4727	return err;4728}4729 4730static int4731vxlan_fdb_external_learn_del(struct net_device *dev,4732			     struct switchdev_notifier_vxlan_fdb_info *fdb_info)4733{4734	struct vxlan_dev *vxlan = netdev_priv(dev);4735	struct vxlan_fdb *f;4736	u32 hash_index;4737	int err = 0;4738 4739	hash_index = fdb_head_index(vxlan, fdb_info->eth_addr, fdb_info->vni);4740	spin_lock_bh(&vxlan->hash_lock[hash_index]);4741 4742	f = vxlan_find_mac(vxlan, fdb_info->eth_addr, fdb_info->vni);4743	if (!f)4744		err = -ENOENT;4745	else if (f->flags & NTF_EXT_LEARNED)4746		err = __vxlan_fdb_delete(vxlan, fdb_info->eth_addr,4747					 fdb_info->remote_ip,4748					 fdb_info->remote_port,4749					 fdb_info->vni,4750					 fdb_info->remote_vni,4751					 fdb_info->remote_ifindex,4752					 false);4753 4754	spin_unlock_bh(&vxlan->hash_lock[hash_index]);4755 4756	return err;4757}4758 4759static int vxlan_switchdev_event(struct notifier_block *unused,4760				 unsigned long event, void *ptr)4761{4762	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);4763	struct switchdev_notifier_vxlan_fdb_info *fdb_info;4764	int err = 0;4765 4766	switch (event) {4767	case SWITCHDEV_VXLAN_FDB_OFFLOADED:4768		vxlan_fdb_offloaded_set(dev, ptr);4769		break;4770	case SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE:4771		fdb_info = ptr;4772		err = vxlan_fdb_external_learn_add(dev, fdb_info);4773		if (err) {4774			err = notifier_from_errno(err);4775			break;4776		}4777		fdb_info->offloaded = true;4778		vxlan_fdb_offloaded_set(dev, fdb_info);4779		break;4780	case SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE:4781		fdb_info = ptr;4782		err = vxlan_fdb_external_learn_del(dev, fdb_info);4783		if (err) {4784			err = notifier_from_errno(err);4785			break;4786		}4787		fdb_info->offloaded = false;4788		vxlan_fdb_offloaded_set(dev, fdb_info);4789		break;4790	}4791 4792	return err;4793}4794 4795static struct notifier_block vxlan_switchdev_notifier_block __read_mostly = {4796	.notifier_call = vxlan_switchdev_event,4797};4798 4799static void vxlan_fdb_nh_flush(struct nexthop *nh)4800{4801	struct vxlan_fdb *fdb;4802	struct vxlan_dev *vxlan;4803	u32 hash_index;4804 4805	rcu_read_lock();4806	list_for_each_entry_rcu(fdb, &nh->fdb_list, nh_list) {4807		vxlan = rcu_dereference(fdb->vdev);4808		WARN_ON(!vxlan);4809		hash_index = fdb_head_index(vxlan, fdb->eth_addr,4810					    vxlan->default_dst.remote_vni);4811		spin_lock_bh(&vxlan->hash_lock[hash_index]);4812		if (!hlist_unhashed(&fdb->hlist))4813			vxlan_fdb_destroy(vxlan, fdb, false, false);4814		spin_unlock_bh(&vxlan->hash_lock[hash_index]);4815	}4816	rcu_read_unlock();4817}4818 4819static int vxlan_nexthop_event(struct notifier_block *nb,4820			       unsigned long event, void *ptr)4821{4822	struct nh_notifier_info *info = ptr;4823	struct nexthop *nh;4824 4825	if (event != NEXTHOP_EVENT_DEL)4826		return NOTIFY_DONE;4827 4828	nh = nexthop_find_by_id(info->net, info->id);4829	if (!nh)4830		return NOTIFY_DONE;4831 4832	vxlan_fdb_nh_flush(nh);4833 4834	return NOTIFY_DONE;4835}4836 4837static __net_init int vxlan_init_net(struct net *net)4838{4839	struct vxlan_net *vn = net_generic(net, vxlan_net_id);4840	unsigned int h;4841 4842	INIT_LIST_HEAD(&vn->vxlan_list);4843	spin_lock_init(&vn->sock_lock);4844	vn->nexthop_notifier_block.notifier_call = vxlan_nexthop_event;4845 4846	for (h = 0; h < PORT_HASH_SIZE; ++h)4847		INIT_HLIST_HEAD(&vn->sock_list[h]);4848 4849	return register_nexthop_notifier(net, &vn->nexthop_notifier_block,4850					 NULL);4851}4852 4853static void __net_exit vxlan_destroy_tunnels(struct vxlan_net *vn,4854					     struct list_head *dev_to_kill)4855{4856	struct vxlan_dev *vxlan, *next;4857 4858	list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next)4859		vxlan_dellink(vxlan->dev, dev_to_kill);4860}4861 4862static void __net_exit vxlan_exit_batch_rtnl(struct list_head *net_list,4863					     struct list_head *dev_to_kill)4864{4865	struct net *net;4866 4867	ASSERT_RTNL();4868	list_for_each_entry(net, net_list, exit_list) {4869		struct vxlan_net *vn = net_generic(net, vxlan_net_id);4870 4871		__unregister_nexthop_notifier(net, &vn->nexthop_notifier_block);4872 4873		vxlan_destroy_tunnels(vn, dev_to_kill);4874	}4875}4876 4877static void __net_exit vxlan_exit_net(struct net *net)4878{4879	struct vxlan_net *vn = net_generic(net, vxlan_net_id);4880	unsigned int h;4881 4882	for (h = 0; h < PORT_HASH_SIZE; ++h)4883		WARN_ON_ONCE(!hlist_empty(&vn->sock_list[h]));4884}4885 4886static struct pernet_operations vxlan_net_ops = {4887	.init = vxlan_init_net,4888	.exit_batch_rtnl = vxlan_exit_batch_rtnl,4889	.exit = vxlan_exit_net,4890	.id   = &vxlan_net_id,4891	.size = sizeof(struct vxlan_net),4892};4893 4894static int __init vxlan_init_module(void)4895{4896	int rc;4897 4898	get_random_bytes(&vxlan_salt, sizeof(vxlan_salt));4899 4900	rc = register_pernet_subsys(&vxlan_net_ops);4901	if (rc)4902		goto out1;4903 4904	rc = register_netdevice_notifier(&vxlan_notifier_block);4905	if (rc)4906		goto out2;4907 4908	rc = register_switchdev_notifier(&vxlan_switchdev_notifier_block);4909	if (rc)4910		goto out3;4911 4912	rc = rtnl_link_register(&vxlan_link_ops);4913	if (rc)4914		goto out4;4915 4916	rc = vxlan_vnifilter_init();4917	if (rc)4918		goto out5;4919 4920	return 0;4921out5:4922	rtnl_link_unregister(&vxlan_link_ops);4923out4:4924	unregister_switchdev_notifier(&vxlan_switchdev_notifier_block);4925out3:4926	unregister_netdevice_notifier(&vxlan_notifier_block);4927out2:4928	unregister_pernet_subsys(&vxlan_net_ops);4929out1:4930	return rc;4931}4932late_initcall(vxlan_init_module);4933 4934static void __exit vxlan_cleanup_module(void)4935{4936	vxlan_vnifilter_uninit();4937	rtnl_link_unregister(&vxlan_link_ops);4938	unregister_switchdev_notifier(&vxlan_switchdev_notifier_block);4939	unregister_netdevice_notifier(&vxlan_notifier_block);4940	unregister_pernet_subsys(&vxlan_net_ops);4941	/* rcu_barrier() is called by netns */4942}4943module_exit(vxlan_cleanup_module);4944 4945MODULE_LICENSE("GPL");4946MODULE_VERSION(VXLAN_VERSION);4947MODULE_AUTHOR("Stephen Hemminger <stephen@networkplumber.org>");4948MODULE_DESCRIPTION("Driver for VXLAN encapsulated traffic");4949MODULE_ALIAS_RTNL_LINK("vxlan");4950