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