xref: /freebsd/sys/net/if_vxlan.c (revision 994297b01b98816bea1abf45ae4bac1bc69ee7a0)
1 /*-
2  * Copyright (c) 2014, Bryan Venteicher <bryanv@FreeBSD.org>
3  * All rights reserved.
4  * Copyright (c) 2020, Chelsio Communications.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice unmodified, this list of conditions, and the following
11  *    disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 #include "opt_inet.h"
29 #include "opt_inet6.h"
30 
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
33 
34 #include <sys/param.h>
35 #include <sys/eventhandler.h>
36 #include <sys/kernel.h>
37 #include <sys/lock.h>
38 #include <sys/hash.h>
39 #include <sys/malloc.h>
40 #include <sys/mbuf.h>
41 #include <sys/module.h>
42 #include <sys/refcount.h>
43 #include <sys/rmlock.h>
44 #include <sys/priv.h>
45 #include <sys/proc.h>
46 #include <sys/queue.h>
47 #include <sys/sbuf.h>
48 #include <sys/socket.h>
49 #include <sys/socketvar.h>
50 #include <sys/sockio.h>
51 #include <sys/sysctl.h>
52 #include <sys/systm.h>
53 
54 #include <net/bpf.h>
55 #include <net/ethernet.h>
56 #include <net/if.h>
57 #include <net/if_var.h>
58 #include <net/if_clone.h>
59 #include <net/if_dl.h>
60 #include <net/if_media.h>
61 #include <net/if_types.h>
62 #include <net/if_vxlan.h>
63 #include <net/netisr.h>
64 #include <net/route.h>
65 #include <net/route/nhop.h>
66 
67 #include <netinet/in.h>
68 #include <netinet/in_systm.h>
69 #include <netinet/in_var.h>
70 #include <netinet/in_pcb.h>
71 #include <netinet/ip.h>
72 #include <netinet/ip6.h>
73 #include <netinet/ip_var.h>
74 #include <netinet/udp.h>
75 #include <netinet/udp_var.h>
76 #include <netinet/in_fib.h>
77 #include <netinet6/in6_fib.h>
78 
79 #include <netinet6/ip6_var.h>
80 #include <netinet6/scope6_var.h>
81 
82 struct vxlan_softc;
83 LIST_HEAD(vxlan_softc_head, vxlan_softc);
84 
85 struct sx vxlan_sx;
86 SX_SYSINIT(vxlan, &vxlan_sx, "VXLAN global start/stop lock");
87 
88 struct vxlan_socket_mc_info {
89 	union vxlan_sockaddr		 vxlsomc_saddr;
90 	union vxlan_sockaddr		 vxlsomc_gaddr;
91 	int				 vxlsomc_ifidx;
92 	int				 vxlsomc_users;
93 };
94 
95 /*
96  * The maximum MTU of encapsulated ethernet frame within IPv4/UDP packet.
97  */
98 #define VXLAN_MAX_MTU	(IP_MAXPACKET - \
99 		60 /* Maximum IPv4 header len */ - \
100 		sizeof(struct udphdr) - \
101 		sizeof(struct vxlan_header) - \
102 		ETHER_HDR_LEN - ETHER_CRC_LEN - ETHER_VLAN_ENCAP_LEN)
103 #define VXLAN_BASIC_IFCAPS (IFCAP_LINKSTATE | IFCAP_JUMBO_MTU)
104 
105 #define VXLAN_SO_MC_MAX_GROUPS		32
106 
107 #define VXLAN_SO_VNI_HASH_SHIFT		6
108 #define VXLAN_SO_VNI_HASH_SIZE		(1 << VXLAN_SO_VNI_HASH_SHIFT)
109 #define VXLAN_SO_VNI_HASH(_vni)		((_vni) % VXLAN_SO_VNI_HASH_SIZE)
110 
111 struct vxlan_socket {
112 	struct socket			*vxlso_sock;
113 	struct rmlock			 vxlso_lock;
114 	u_int				 vxlso_refcnt;
115 	union vxlan_sockaddr		 vxlso_laddr;
116 	LIST_ENTRY(vxlan_socket)	 vxlso_entry;
117 	struct vxlan_softc_head		 vxlso_vni_hash[VXLAN_SO_VNI_HASH_SIZE];
118 	struct vxlan_socket_mc_info	 vxlso_mc[VXLAN_SO_MC_MAX_GROUPS];
119 };
120 
121 #define VXLAN_SO_RLOCK(_vso, _p)	rm_rlock(&(_vso)->vxlso_lock, (_p))
122 #define VXLAN_SO_RUNLOCK(_vso, _p)	rm_runlock(&(_vso)->vxlso_lock, (_p))
123 #define VXLAN_SO_WLOCK(_vso)		rm_wlock(&(_vso)->vxlso_lock)
124 #define VXLAN_SO_WUNLOCK(_vso)		rm_wunlock(&(_vso)->vxlso_lock)
125 #define VXLAN_SO_LOCK_ASSERT(_vso) \
126     rm_assert(&(_vso)->vxlso_lock, RA_LOCKED)
127 #define VXLAN_SO_LOCK_WASSERT(_vso) \
128     rm_assert(&(_vso)->vxlso_lock, RA_WLOCKED)
129 
130 #define VXLAN_SO_ACQUIRE(_vso)		refcount_acquire(&(_vso)->vxlso_refcnt)
131 #define VXLAN_SO_RELEASE(_vso)		refcount_release(&(_vso)->vxlso_refcnt)
132 
133 struct vxlan_ftable_entry {
134 	LIST_ENTRY(vxlan_ftable_entry)	 vxlfe_hash;
135 	uint16_t			 vxlfe_flags;
136 	uint8_t				 vxlfe_mac[ETHER_ADDR_LEN];
137 	union vxlan_sockaddr		 vxlfe_raddr;
138 	time_t				 vxlfe_expire;
139 };
140 
141 #define VXLAN_FE_FLAG_DYNAMIC		0x01
142 #define VXLAN_FE_FLAG_STATIC		0x02
143 
144 #define VXLAN_FE_IS_DYNAMIC(_fe) \
145     ((_fe)->vxlfe_flags & VXLAN_FE_FLAG_DYNAMIC)
146 
147 #define VXLAN_SC_FTABLE_SHIFT		9
148 #define VXLAN_SC_FTABLE_SIZE		(1 << VXLAN_SC_FTABLE_SHIFT)
149 #define VXLAN_SC_FTABLE_MASK		(VXLAN_SC_FTABLE_SIZE - 1)
150 #define VXLAN_SC_FTABLE_HASH(_sc, _mac)	\
151     (vxlan_mac_hash(_sc, _mac) % VXLAN_SC_FTABLE_SIZE)
152 
153 LIST_HEAD(vxlan_ftable_head, vxlan_ftable_entry);
154 
155 struct vxlan_statistics {
156 	uint32_t	ftable_nospace;
157 	uint32_t	ftable_lock_upgrade_failed;
158 	counter_u64_t	txcsum;
159 	counter_u64_t	tso;
160 	counter_u64_t	rxcsum;
161 };
162 
163 struct vxlan_softc {
164 	struct ifnet			*vxl_ifp;
165 	int				 vxl_reqcap;
166 	struct vxlan_socket		*vxl_sock;
167 	uint32_t			 vxl_vni;
168 	union vxlan_sockaddr		 vxl_src_addr;
169 	union vxlan_sockaddr		 vxl_dst_addr;
170 	uint32_t			 vxl_flags;
171 #define VXLAN_FLAG_INIT		0x0001
172 #define VXLAN_FLAG_TEARDOWN	0x0002
173 #define VXLAN_FLAG_LEARN	0x0004
174 #define VXLAN_FLAG_USER_MTU	0x0008
175 
176 	uint32_t			 vxl_port_hash_key;
177 	uint16_t			 vxl_min_port;
178 	uint16_t			 vxl_max_port;
179 	uint8_t				 vxl_ttl;
180 
181 	/* Lookup table from MAC address to forwarding entry. */
182 	uint32_t			 vxl_ftable_cnt;
183 	uint32_t			 vxl_ftable_max;
184 	uint32_t			 vxl_ftable_timeout;
185 	uint32_t			 vxl_ftable_hash_key;
186 	struct vxlan_ftable_head	*vxl_ftable;
187 
188 	/* Derived from vxl_dst_addr. */
189 	struct vxlan_ftable_entry	 vxl_default_fe;
190 
191 	struct ip_moptions		*vxl_im4o;
192 	struct ip6_moptions		*vxl_im6o;
193 
194 	struct rmlock			 vxl_lock;
195 	volatile u_int			 vxl_refcnt;
196 
197 	int				 vxl_unit;
198 	int				 vxl_vso_mc_index;
199 	struct vxlan_statistics		 vxl_stats;
200 	struct sysctl_oid		*vxl_sysctl_node;
201 	struct sysctl_ctx_list		 vxl_sysctl_ctx;
202 	struct callout			 vxl_callout;
203 	struct ether_addr		 vxl_hwaddr;
204 	int				 vxl_mc_ifindex;
205 	struct ifnet			*vxl_mc_ifp;
206 	struct ifmedia 			 vxl_media;
207 	char				 vxl_mc_ifname[IFNAMSIZ];
208 	LIST_ENTRY(vxlan_softc)		 vxl_entry;
209 	LIST_ENTRY(vxlan_softc)		 vxl_ifdetach_list;
210 
211 	/* For rate limiting errors on the tx fast path. */
212 	struct timeval err_time;
213 	int err_pps;
214 };
215 
216 #define VXLAN_RLOCK(_sc, _p)	rm_rlock(&(_sc)->vxl_lock, (_p))
217 #define VXLAN_RUNLOCK(_sc, _p)	rm_runlock(&(_sc)->vxl_lock, (_p))
218 #define VXLAN_WLOCK(_sc)	rm_wlock(&(_sc)->vxl_lock)
219 #define VXLAN_WUNLOCK(_sc)	rm_wunlock(&(_sc)->vxl_lock)
220 #define VXLAN_LOCK_WOWNED(_sc)	rm_wowned(&(_sc)->vxl_lock)
221 #define VXLAN_LOCK_ASSERT(_sc)	rm_assert(&(_sc)->vxl_lock, RA_LOCKED)
222 #define VXLAN_LOCK_WASSERT(_sc) rm_assert(&(_sc)->vxl_lock, RA_WLOCKED)
223 #define VXLAN_UNLOCK(_sc, _p) do {		\
224     if (VXLAN_LOCK_WOWNED(_sc))			\
225 	VXLAN_WUNLOCK(_sc);			\
226     else					\
227 	VXLAN_RUNLOCK(_sc, _p);			\
228 } while (0)
229 
230 #define VXLAN_ACQUIRE(_sc)	refcount_acquire(&(_sc)->vxl_refcnt)
231 #define VXLAN_RELEASE(_sc)	refcount_release(&(_sc)->vxl_refcnt)
232 
233 #define	satoconstsin(sa)	((const struct sockaddr_in *)(sa))
234 #define	satoconstsin6(sa)	((const struct sockaddr_in6 *)(sa))
235 
236 struct vxlanudphdr {
237 	struct udphdr		vxlh_udp;
238 	struct vxlan_header	vxlh_hdr;
239 } __packed;
240 
241 static int	vxlan_ftable_addr_cmp(const uint8_t *, const uint8_t *);
242 static void	vxlan_ftable_init(struct vxlan_softc *);
243 static void	vxlan_ftable_fini(struct vxlan_softc *);
244 static void	vxlan_ftable_flush(struct vxlan_softc *, int);
245 static void	vxlan_ftable_expire(struct vxlan_softc *);
246 static int	vxlan_ftable_update_locked(struct vxlan_softc *,
247 		    const union vxlan_sockaddr *, const uint8_t *,
248 		    struct rm_priotracker *);
249 static int	vxlan_ftable_learn(struct vxlan_softc *,
250 		    const struct sockaddr *, const uint8_t *);
251 static int	vxlan_ftable_sysctl_dump(SYSCTL_HANDLER_ARGS);
252 
253 static struct vxlan_ftable_entry *
254 		vxlan_ftable_entry_alloc(void);
255 static void	vxlan_ftable_entry_free(struct vxlan_ftable_entry *);
256 static void	vxlan_ftable_entry_init(struct vxlan_softc *,
257 		    struct vxlan_ftable_entry *, const uint8_t *,
258 		    const struct sockaddr *, uint32_t);
259 static void	vxlan_ftable_entry_destroy(struct vxlan_softc *,
260 		    struct vxlan_ftable_entry *);
261 static int	vxlan_ftable_entry_insert(struct vxlan_softc *,
262 		    struct vxlan_ftable_entry *);
263 static struct vxlan_ftable_entry *
264 		vxlan_ftable_entry_lookup(struct vxlan_softc *,
265 		    const uint8_t *);
266 static void	vxlan_ftable_entry_dump(struct vxlan_ftable_entry *,
267 		    struct sbuf *);
268 
269 static struct vxlan_socket *
270 		vxlan_socket_alloc(const union vxlan_sockaddr *);
271 static void	vxlan_socket_destroy(struct vxlan_socket *);
272 static void	vxlan_socket_release(struct vxlan_socket *);
273 static struct vxlan_socket *
274 		vxlan_socket_lookup(union vxlan_sockaddr *vxlsa);
275 static void	vxlan_socket_insert(struct vxlan_socket *);
276 static int	vxlan_socket_init(struct vxlan_socket *, struct ifnet *);
277 static int	vxlan_socket_bind(struct vxlan_socket *, struct ifnet *);
278 static int	vxlan_socket_create(struct ifnet *, int,
279 		    const union vxlan_sockaddr *, struct vxlan_socket **);
280 static void	vxlan_socket_ifdetach(struct vxlan_socket *,
281 		    struct ifnet *, struct vxlan_softc_head *);
282 
283 static struct vxlan_socket *
284 		vxlan_socket_mc_lookup(const union vxlan_sockaddr *);
285 static int	vxlan_sockaddr_mc_info_match(
286 		    const struct vxlan_socket_mc_info *,
287 		    const union vxlan_sockaddr *,
288 		    const union vxlan_sockaddr *, int);
289 static int	vxlan_socket_mc_join_group(struct vxlan_socket *,
290 		    const union vxlan_sockaddr *, const union vxlan_sockaddr *,
291 		    int *, union vxlan_sockaddr *);
292 static int	vxlan_socket_mc_leave_group(struct vxlan_socket *,
293 		    const union vxlan_sockaddr *,
294 		    const union vxlan_sockaddr *, int);
295 static int	vxlan_socket_mc_add_group(struct vxlan_socket *,
296 		    const union vxlan_sockaddr *, const union vxlan_sockaddr *,
297 		    int, int *);
298 static void	vxlan_socket_mc_release_group_by_idx(struct vxlan_socket *,
299 		    int);
300 
301 static struct vxlan_softc *
302 		vxlan_socket_lookup_softc_locked(struct vxlan_socket *,
303 		    uint32_t);
304 static struct vxlan_softc *
305 		vxlan_socket_lookup_softc(struct vxlan_socket *, uint32_t);
306 static int	vxlan_socket_insert_softc(struct vxlan_socket *,
307 		    struct vxlan_softc *);
308 static void	vxlan_socket_remove_softc(struct vxlan_socket *,
309 		    struct vxlan_softc *);
310 
311 static struct ifnet *
312 		vxlan_multicast_if_ref(struct vxlan_softc *, int);
313 static void	vxlan_free_multicast(struct vxlan_softc *);
314 static int	vxlan_setup_multicast_interface(struct vxlan_softc *);
315 
316 static int	vxlan_setup_multicast(struct vxlan_softc *);
317 static int	vxlan_setup_socket(struct vxlan_softc *);
318 #ifdef INET6
319 static void	vxlan_setup_zero_checksum_port(struct vxlan_softc *);
320 #endif
321 static void	vxlan_setup_interface_hdrlen(struct vxlan_softc *);
322 static int	vxlan_valid_init_config(struct vxlan_softc *);
323 static void	vxlan_init_wait(struct vxlan_softc *);
324 static void	vxlan_init_complete(struct vxlan_softc *);
325 static void	vxlan_init(void *);
326 static void	vxlan_release(struct vxlan_softc *);
327 static void	vxlan_teardown_wait(struct vxlan_softc *);
328 static void	vxlan_teardown_complete(struct vxlan_softc *);
329 static void	vxlan_teardown_locked(struct vxlan_softc *);
330 static void	vxlan_teardown(struct vxlan_softc *);
331 static void	vxlan_ifdetach(struct vxlan_softc *, struct ifnet *,
332 		    struct vxlan_softc_head *);
333 static void	vxlan_timer(void *);
334 
335 static int	vxlan_ctrl_get_config(struct vxlan_softc *, void *);
336 static int	vxlan_ctrl_set_vni(struct vxlan_softc *, void *);
337 static int	vxlan_ctrl_set_local_addr(struct vxlan_softc *, void *);
338 static int	vxlan_ctrl_set_remote_addr(struct vxlan_softc *, void *);
339 static int	vxlan_ctrl_set_local_port(struct vxlan_softc *, void *);
340 static int	vxlan_ctrl_set_remote_port(struct vxlan_softc *, void *);
341 static int	vxlan_ctrl_set_port_range(struct vxlan_softc *, void *);
342 static int	vxlan_ctrl_set_ftable_timeout(struct vxlan_softc *, void *);
343 static int	vxlan_ctrl_set_ftable_max(struct vxlan_softc *, void *);
344 static int	vxlan_ctrl_set_multicast_if(struct vxlan_softc * , void *);
345 static int	vxlan_ctrl_set_ttl(struct vxlan_softc *, void *);
346 static int	vxlan_ctrl_set_learn(struct vxlan_softc *, void *);
347 static int	vxlan_ctrl_ftable_entry_add(struct vxlan_softc *, void *);
348 static int	vxlan_ctrl_ftable_entry_rem(struct vxlan_softc *, void *);
349 static int	vxlan_ctrl_flush(struct vxlan_softc *, void *);
350 static int	vxlan_ioctl_drvspec(struct vxlan_softc *,
351 		    struct ifdrv *, int);
352 static int	vxlan_ioctl_ifflags(struct vxlan_softc *);
353 static int	vxlan_ioctl(struct ifnet *, u_long, caddr_t);
354 
355 #if defined(INET) || defined(INET6)
356 static uint16_t vxlan_pick_source_port(struct vxlan_softc *, struct mbuf *);
357 static void	vxlan_encap_header(struct vxlan_softc *, struct mbuf *,
358 		    int, uint16_t, uint16_t);
359 #endif
360 static int	vxlan_encap4(struct vxlan_softc *,
361 		    const union vxlan_sockaddr *, struct mbuf *);
362 static int	vxlan_encap6(struct vxlan_softc *,
363 		    const union vxlan_sockaddr *, struct mbuf *);
364 static int	vxlan_transmit(struct ifnet *, struct mbuf *);
365 static void	vxlan_qflush(struct ifnet *);
366 static void	vxlan_rcv_udp_packet(struct mbuf *, int, struct inpcb *,
367 		    const struct sockaddr *, void *);
368 static int	vxlan_input(struct vxlan_socket *, uint32_t, struct mbuf **,
369 		    const struct sockaddr *);
370 
371 static int	vxlan_stats_alloc(struct vxlan_softc *);
372 static void	vxlan_stats_free(struct vxlan_softc *);
373 static void	vxlan_set_default_config(struct vxlan_softc *);
374 static int	vxlan_set_user_config(struct vxlan_softc *,
375 		     struct ifvxlanparam *);
376 static int	vxlan_set_reqcap(struct vxlan_softc *, struct ifnet *, int);
377 static void	vxlan_set_hwcaps(struct vxlan_softc *);
378 static int	vxlan_clone_create(struct if_clone *, int, caddr_t);
379 static void	vxlan_clone_destroy(struct ifnet *);
380 
381 static uint32_t vxlan_mac_hash(struct vxlan_softc *, const uint8_t *);
382 static int	vxlan_media_change(struct ifnet *);
383 static void	vxlan_media_status(struct ifnet *, struct ifmediareq *);
384 
385 static int	vxlan_sockaddr_cmp(const union vxlan_sockaddr *,
386 		    const struct sockaddr *);
387 static void	vxlan_sockaddr_copy(union vxlan_sockaddr *,
388 		    const struct sockaddr *);
389 static int	vxlan_sockaddr_in_equal(const union vxlan_sockaddr *,
390 		    const struct sockaddr *);
391 static void	vxlan_sockaddr_in_copy(union vxlan_sockaddr *,
392 		    const struct sockaddr *);
393 static int	vxlan_sockaddr_supported(const union vxlan_sockaddr *, int);
394 static int	vxlan_sockaddr_in_any(const union vxlan_sockaddr *);
395 static int	vxlan_sockaddr_in_multicast(const union vxlan_sockaddr *);
396 static int	vxlan_sockaddr_in6_embedscope(union vxlan_sockaddr *);
397 
398 static int	vxlan_can_change_config(struct vxlan_softc *);
399 static int	vxlan_check_vni(uint32_t);
400 static int	vxlan_check_ttl(int);
401 static int	vxlan_check_ftable_timeout(uint32_t);
402 static int	vxlan_check_ftable_max(uint32_t);
403 
404 static void	vxlan_sysctl_setup(struct vxlan_softc *);
405 static void	vxlan_sysctl_destroy(struct vxlan_softc *);
406 static int	vxlan_tunable_int(struct vxlan_softc *, const char *, int);
407 
408 static void	vxlan_ifdetach_event(void *, struct ifnet *);
409 static void	vxlan_load(void);
410 static void	vxlan_unload(void);
411 static int	vxlan_modevent(module_t, int, void *);
412 
413 static const char vxlan_name[] = "vxlan";
414 static MALLOC_DEFINE(M_VXLAN, vxlan_name,
415     "Virtual eXtensible LAN Interface");
416 static struct if_clone *vxlan_cloner;
417 
418 static struct mtx vxlan_list_mtx;
419 #define VXLAN_LIST_LOCK()	mtx_lock(&vxlan_list_mtx)
420 #define VXLAN_LIST_UNLOCK()	mtx_unlock(&vxlan_list_mtx)
421 
422 static LIST_HEAD(, vxlan_socket) vxlan_socket_list;
423 
424 static eventhandler_tag vxlan_ifdetach_event_tag;
425 
426 SYSCTL_DECL(_net_link);
427 SYSCTL_NODE(_net_link, OID_AUTO, vxlan, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
428     "Virtual eXtensible Local Area Network");
429 
430 static int vxlan_legacy_port = 0;
431 TUNABLE_INT("net.link.vxlan.legacy_port", &vxlan_legacy_port);
432 static int vxlan_reuse_port = 0;
433 TUNABLE_INT("net.link.vxlan.reuse_port", &vxlan_reuse_port);
434 
435 /* Default maximum number of addresses in the forwarding table. */
436 #ifndef VXLAN_FTABLE_MAX
437 #define VXLAN_FTABLE_MAX	2000
438 #endif
439 
440 /* Timeout (in seconds) of addresses learned in the forwarding table. */
441 #ifndef VXLAN_FTABLE_TIMEOUT
442 #define VXLAN_FTABLE_TIMEOUT	(20 * 60)
443 #endif
444 
445 /*
446  * Maximum timeout (in seconds) of addresses learned in the forwarding
447  * table.
448  */
449 #ifndef VXLAN_FTABLE_MAX_TIMEOUT
450 #define VXLAN_FTABLE_MAX_TIMEOUT	(60 * 60 * 24)
451 #endif
452 
453 /* Number of seconds between pruning attempts of the forwarding table. */
454 #ifndef VXLAN_FTABLE_PRUNE
455 #define VXLAN_FTABLE_PRUNE	(5 * 60)
456 #endif
457 
458 static int vxlan_ftable_prune_period = VXLAN_FTABLE_PRUNE;
459 
460 struct vxlan_control {
461 	int	(*vxlc_func)(struct vxlan_softc *, void *);
462 	int	vxlc_argsize;
463 	int	vxlc_flags;
464 #define VXLAN_CTRL_FLAG_COPYIN	0x01
465 #define VXLAN_CTRL_FLAG_COPYOUT	0x02
466 #define VXLAN_CTRL_FLAG_SUSER	0x04
467 };
468 
469 static const struct vxlan_control vxlan_control_table[] = {
470 	[VXLAN_CMD_GET_CONFIG] =
471 	    {	vxlan_ctrl_get_config, sizeof(struct ifvxlancfg),
472 		VXLAN_CTRL_FLAG_COPYOUT
473 	    },
474 
475 	[VXLAN_CMD_SET_VNI] =
476 	    {   vxlan_ctrl_set_vni, sizeof(struct ifvxlancmd),
477 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
478 	    },
479 
480 	[VXLAN_CMD_SET_LOCAL_ADDR] =
481 	    {   vxlan_ctrl_set_local_addr, sizeof(struct ifvxlancmd),
482 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
483 	    },
484 
485 	[VXLAN_CMD_SET_REMOTE_ADDR] =
486 	    {   vxlan_ctrl_set_remote_addr, sizeof(struct ifvxlancmd),
487 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
488 	    },
489 
490 	[VXLAN_CMD_SET_LOCAL_PORT] =
491 	    {   vxlan_ctrl_set_local_port, sizeof(struct ifvxlancmd),
492 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
493 	    },
494 
495 	[VXLAN_CMD_SET_REMOTE_PORT] =
496 	    {   vxlan_ctrl_set_remote_port, sizeof(struct ifvxlancmd),
497 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
498 	    },
499 
500 	[VXLAN_CMD_SET_PORT_RANGE] =
501 	    {   vxlan_ctrl_set_port_range, sizeof(struct ifvxlancmd),
502 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
503 	    },
504 
505 	[VXLAN_CMD_SET_FTABLE_TIMEOUT] =
506 	    {	vxlan_ctrl_set_ftable_timeout, sizeof(struct ifvxlancmd),
507 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
508 	    },
509 
510 	[VXLAN_CMD_SET_FTABLE_MAX] =
511 	    {	vxlan_ctrl_set_ftable_max, sizeof(struct ifvxlancmd),
512 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
513 	    },
514 
515 	[VXLAN_CMD_SET_MULTICAST_IF] =
516 	    {	vxlan_ctrl_set_multicast_if, sizeof(struct ifvxlancmd),
517 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
518 	    },
519 
520 	[VXLAN_CMD_SET_TTL] =
521 	    {	vxlan_ctrl_set_ttl, sizeof(struct ifvxlancmd),
522 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
523 	    },
524 
525 	[VXLAN_CMD_SET_LEARN] =
526 	    {	vxlan_ctrl_set_learn, sizeof(struct ifvxlancmd),
527 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
528 	    },
529 
530 	[VXLAN_CMD_FTABLE_ENTRY_ADD] =
531 	    {	vxlan_ctrl_ftable_entry_add, sizeof(struct ifvxlancmd),
532 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
533 	    },
534 
535 	[VXLAN_CMD_FTABLE_ENTRY_REM] =
536 	    {	vxlan_ctrl_ftable_entry_rem, sizeof(struct ifvxlancmd),
537 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
538 	    },
539 
540 	[VXLAN_CMD_FLUSH] =
541 	    {   vxlan_ctrl_flush, sizeof(struct ifvxlancmd),
542 		VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
543 	    },
544 };
545 
546 static const int vxlan_control_table_size = nitems(vxlan_control_table);
547 
548 static int
549 vxlan_ftable_addr_cmp(const uint8_t *a, const uint8_t *b)
550 {
551 	int i, d;
552 
553 	for (i = 0, d = 0; i < ETHER_ADDR_LEN && d == 0; i++)
554 		d = ((int)a[i]) - ((int)b[i]);
555 
556 	return (d);
557 }
558 
559 static void
560 vxlan_ftable_init(struct vxlan_softc *sc)
561 {
562 	int i;
563 
564 	sc->vxl_ftable = malloc(sizeof(struct vxlan_ftable_head) *
565 	    VXLAN_SC_FTABLE_SIZE, M_VXLAN, M_ZERO | M_WAITOK);
566 
567 	for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++)
568 		LIST_INIT(&sc->vxl_ftable[i]);
569 	sc->vxl_ftable_hash_key = arc4random();
570 }
571 
572 static void
573 vxlan_ftable_fini(struct vxlan_softc *sc)
574 {
575 	int i;
576 
577 	for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
578 		KASSERT(LIST_EMPTY(&sc->vxl_ftable[i]),
579 		    ("%s: vxlan %p ftable[%d] not empty", __func__, sc, i));
580 	}
581 	MPASS(sc->vxl_ftable_cnt == 0);
582 
583 	free(sc->vxl_ftable, M_VXLAN);
584 	sc->vxl_ftable = NULL;
585 }
586 
587 static void
588 vxlan_ftable_flush(struct vxlan_softc *sc, int all)
589 {
590 	struct vxlan_ftable_entry *fe, *tfe;
591 	int i;
592 
593 	for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
594 		LIST_FOREACH_SAFE(fe, &sc->vxl_ftable[i], vxlfe_hash, tfe) {
595 			if (all || VXLAN_FE_IS_DYNAMIC(fe))
596 				vxlan_ftable_entry_destroy(sc, fe);
597 		}
598 	}
599 }
600 
601 static void
602 vxlan_ftable_expire(struct vxlan_softc *sc)
603 {
604 	struct vxlan_ftable_entry *fe, *tfe;
605 	int i;
606 
607 	VXLAN_LOCK_WASSERT(sc);
608 
609 	for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
610 		LIST_FOREACH_SAFE(fe, &sc->vxl_ftable[i], vxlfe_hash, tfe) {
611 			if (VXLAN_FE_IS_DYNAMIC(fe) &&
612 			    time_uptime >= fe->vxlfe_expire)
613 				vxlan_ftable_entry_destroy(sc, fe);
614 		}
615 	}
616 }
617 
618 static int
619 vxlan_ftable_update_locked(struct vxlan_softc *sc,
620     const union vxlan_sockaddr *vxlsa, const uint8_t *mac,
621     struct rm_priotracker *tracker)
622 {
623 	struct vxlan_ftable_entry *fe;
624 	int error __unused;
625 
626 	VXLAN_LOCK_ASSERT(sc);
627 
628 again:
629 	/*
630 	 * A forwarding entry for this MAC address might already exist. If
631 	 * so, update it, otherwise create a new one. We may have to upgrade
632 	 * the lock if we have to change or create an entry.
633 	 */
634 	fe = vxlan_ftable_entry_lookup(sc, mac);
635 	if (fe != NULL) {
636 		fe->vxlfe_expire = time_uptime + sc->vxl_ftable_timeout;
637 
638 		if (!VXLAN_FE_IS_DYNAMIC(fe) ||
639 		    vxlan_sockaddr_in_equal(&fe->vxlfe_raddr, &vxlsa->sa))
640 			return (0);
641 		if (!VXLAN_LOCK_WOWNED(sc)) {
642 			VXLAN_RUNLOCK(sc, tracker);
643 			VXLAN_WLOCK(sc);
644 			sc->vxl_stats.ftable_lock_upgrade_failed++;
645 			goto again;
646 		}
647 		vxlan_sockaddr_in_copy(&fe->vxlfe_raddr, &vxlsa->sa);
648 		return (0);
649 	}
650 
651 	if (!VXLAN_LOCK_WOWNED(sc)) {
652 		VXLAN_RUNLOCK(sc, tracker);
653 		VXLAN_WLOCK(sc);
654 		sc->vxl_stats.ftable_lock_upgrade_failed++;
655 		goto again;
656 	}
657 
658 	if (sc->vxl_ftable_cnt >= sc->vxl_ftable_max) {
659 		sc->vxl_stats.ftable_nospace++;
660 		return (ENOSPC);
661 	}
662 
663 	fe = vxlan_ftable_entry_alloc();
664 	if (fe == NULL)
665 		return (ENOMEM);
666 
667 	vxlan_ftable_entry_init(sc, fe, mac, &vxlsa->sa, VXLAN_FE_FLAG_DYNAMIC);
668 
669 	/* The prior lookup failed, so the insert should not. */
670 	error = vxlan_ftable_entry_insert(sc, fe);
671 	MPASS(error == 0);
672 
673 	return (0);
674 }
675 
676 static int
677 vxlan_ftable_learn(struct vxlan_softc *sc, const struct sockaddr *sa,
678     const uint8_t *mac)
679 {
680 	struct rm_priotracker tracker;
681 	union vxlan_sockaddr vxlsa;
682 	int error;
683 
684 	/*
685 	 * The source port may be randomly selected by the remote host, so
686 	 * use the port of the default destination address.
687 	 */
688 	vxlan_sockaddr_copy(&vxlsa, sa);
689 	vxlsa.in4.sin_port = sc->vxl_dst_addr.in4.sin_port;
690 
691 	if (VXLAN_SOCKADDR_IS_IPV6(&vxlsa)) {
692 		error = vxlan_sockaddr_in6_embedscope(&vxlsa);
693 		if (error)
694 			return (error);
695 	}
696 
697 	VXLAN_RLOCK(sc, &tracker);
698 	error = vxlan_ftable_update_locked(sc, &vxlsa, mac, &tracker);
699 	VXLAN_UNLOCK(sc, &tracker);
700 
701 	return (error);
702 }
703 
704 static int
705 vxlan_ftable_sysctl_dump(SYSCTL_HANDLER_ARGS)
706 {
707 	struct rm_priotracker tracker;
708 	struct sbuf sb;
709 	struct vxlan_softc *sc;
710 	struct vxlan_ftable_entry *fe;
711 	size_t size;
712 	int i, error;
713 
714 	/*
715 	 * This is mostly intended for debugging during development. It is
716 	 * not practical to dump an entire large table this way.
717 	 */
718 
719 	sc = arg1;
720 	size = PAGE_SIZE;	/* Calculate later. */
721 
722 	sbuf_new(&sb, NULL, size, SBUF_FIXEDLEN);
723 	sbuf_putc(&sb, '\n');
724 
725 	VXLAN_RLOCK(sc, &tracker);
726 	for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
727 		LIST_FOREACH(fe, &sc->vxl_ftable[i], vxlfe_hash) {
728 			if (sbuf_error(&sb) != 0)
729 				break;
730 			vxlan_ftable_entry_dump(fe, &sb);
731 		}
732 	}
733 	VXLAN_RUNLOCK(sc, &tracker);
734 
735 	if (sbuf_len(&sb) == 1)
736 		sbuf_setpos(&sb, 0);
737 
738 	sbuf_finish(&sb);
739 	error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
740 	sbuf_delete(&sb);
741 
742 	return (error);
743 }
744 
745 static struct vxlan_ftable_entry *
746 vxlan_ftable_entry_alloc(void)
747 {
748 	struct vxlan_ftable_entry *fe;
749 
750 	fe = malloc(sizeof(*fe), M_VXLAN, M_ZERO | M_NOWAIT);
751 
752 	return (fe);
753 }
754 
755 static void
756 vxlan_ftable_entry_free(struct vxlan_ftable_entry *fe)
757 {
758 
759 	free(fe, M_VXLAN);
760 }
761 
762 static void
763 vxlan_ftable_entry_init(struct vxlan_softc *sc, struct vxlan_ftable_entry *fe,
764     const uint8_t *mac, const struct sockaddr *sa, uint32_t flags)
765 {
766 
767 	fe->vxlfe_flags = flags;
768 	fe->vxlfe_expire = time_uptime + sc->vxl_ftable_timeout;
769 	memcpy(fe->vxlfe_mac, mac, ETHER_ADDR_LEN);
770 	vxlan_sockaddr_copy(&fe->vxlfe_raddr, sa);
771 }
772 
773 static void
774 vxlan_ftable_entry_destroy(struct vxlan_softc *sc,
775     struct vxlan_ftable_entry *fe)
776 {
777 
778 	sc->vxl_ftable_cnt--;
779 	LIST_REMOVE(fe, vxlfe_hash);
780 	vxlan_ftable_entry_free(fe);
781 }
782 
783 static int
784 vxlan_ftable_entry_insert(struct vxlan_softc *sc,
785     struct vxlan_ftable_entry *fe)
786 {
787 	struct vxlan_ftable_entry *lfe;
788 	uint32_t hash;
789 	int dir;
790 
791 	VXLAN_LOCK_WASSERT(sc);
792 	hash = VXLAN_SC_FTABLE_HASH(sc, fe->vxlfe_mac);
793 
794 	lfe = LIST_FIRST(&sc->vxl_ftable[hash]);
795 	if (lfe == NULL) {
796 		LIST_INSERT_HEAD(&sc->vxl_ftable[hash], fe, vxlfe_hash);
797 		goto out;
798 	}
799 
800 	do {
801 		dir = vxlan_ftable_addr_cmp(fe->vxlfe_mac, lfe->vxlfe_mac);
802 		if (dir == 0)
803 			return (EEXIST);
804 		if (dir > 0) {
805 			LIST_INSERT_BEFORE(lfe, fe, vxlfe_hash);
806 			goto out;
807 		} else if (LIST_NEXT(lfe, vxlfe_hash) == NULL) {
808 			LIST_INSERT_AFTER(lfe, fe, vxlfe_hash);
809 			goto out;
810 		} else
811 			lfe = LIST_NEXT(lfe, vxlfe_hash);
812 	} while (lfe != NULL);
813 
814 out:
815 	sc->vxl_ftable_cnt++;
816 
817 	return (0);
818 }
819 
820 static struct vxlan_ftable_entry *
821 vxlan_ftable_entry_lookup(struct vxlan_softc *sc, const uint8_t *mac)
822 {
823 	struct vxlan_ftable_entry *fe;
824 	uint32_t hash;
825 	int dir;
826 
827 	VXLAN_LOCK_ASSERT(sc);
828 	hash = VXLAN_SC_FTABLE_HASH(sc, mac);
829 
830 	LIST_FOREACH(fe, &sc->vxl_ftable[hash], vxlfe_hash) {
831 		dir = vxlan_ftable_addr_cmp(mac, fe->vxlfe_mac);
832 		if (dir == 0)
833 			return (fe);
834 		if (dir > 0)
835 			break;
836 	}
837 
838 	return (NULL);
839 }
840 
841 static void
842 vxlan_ftable_entry_dump(struct vxlan_ftable_entry *fe, struct sbuf *sb)
843 {
844 	char buf[64];
845 	const union vxlan_sockaddr *sa;
846 	const void *addr;
847 	int i, len, af, width;
848 
849 	sa = &fe->vxlfe_raddr;
850 	af = sa->sa.sa_family;
851 	len = sbuf_len(sb);
852 
853 	sbuf_printf(sb, "%c 0x%02X ", VXLAN_FE_IS_DYNAMIC(fe) ? 'D' : 'S',
854 	    fe->vxlfe_flags);
855 
856 	for (i = 0; i < ETHER_ADDR_LEN - 1; i++)
857 		sbuf_printf(sb, "%02X:", fe->vxlfe_mac[i]);
858 	sbuf_printf(sb, "%02X ", fe->vxlfe_mac[i]);
859 
860 	if (af == AF_INET) {
861 		addr = &sa->in4.sin_addr;
862 		width = INET_ADDRSTRLEN - 1;
863 	} else {
864 		addr = &sa->in6.sin6_addr;
865 		width = INET6_ADDRSTRLEN - 1;
866 	}
867 	inet_ntop(af, addr, buf, sizeof(buf));
868 	sbuf_printf(sb, "%*s ", width, buf);
869 
870 	sbuf_printf(sb, "%08jd", (intmax_t)fe->vxlfe_expire);
871 
872 	sbuf_putc(sb, '\n');
873 
874 	/* Truncate a partial line. */
875 	if (sbuf_error(sb) != 0)
876 		sbuf_setpos(sb, len);
877 }
878 
879 static struct vxlan_socket *
880 vxlan_socket_alloc(const union vxlan_sockaddr *sa)
881 {
882 	struct vxlan_socket *vso;
883 	int i;
884 
885 	vso = malloc(sizeof(*vso), M_VXLAN, M_WAITOK | M_ZERO);
886 	rm_init(&vso->vxlso_lock, "vxlansorm");
887 	refcount_init(&vso->vxlso_refcnt, 0);
888 	for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++)
889 		LIST_INIT(&vso->vxlso_vni_hash[i]);
890 	vso->vxlso_laddr = *sa;
891 
892 	return (vso);
893 }
894 
895 static void
896 vxlan_socket_destroy(struct vxlan_socket *vso)
897 {
898 	struct socket *so;
899 #ifdef INVARIANTS
900 	int i;
901 	struct vxlan_socket_mc_info *mc;
902 
903 	for (i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
904 		mc = &vso->vxlso_mc[i];
905 		KASSERT(mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC,
906 		    ("%s: socket %p mc[%d] still has address",
907 		     __func__, vso, i));
908 	}
909 
910 	for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++) {
911 		KASSERT(LIST_EMPTY(&vso->vxlso_vni_hash[i]),
912 		    ("%s: socket %p vni_hash[%d] not empty",
913 		     __func__, vso, i));
914 	}
915 #endif
916 	so = vso->vxlso_sock;
917 	if (so != NULL) {
918 		vso->vxlso_sock = NULL;
919 		soclose(so);
920 	}
921 
922 	rm_destroy(&vso->vxlso_lock);
923 	free(vso, M_VXLAN);
924 }
925 
926 static void
927 vxlan_socket_release(struct vxlan_socket *vso)
928 {
929 	int destroy;
930 
931 	VXLAN_LIST_LOCK();
932 	destroy = VXLAN_SO_RELEASE(vso);
933 	if (destroy != 0)
934 		LIST_REMOVE(vso, vxlso_entry);
935 	VXLAN_LIST_UNLOCK();
936 
937 	if (destroy != 0)
938 		vxlan_socket_destroy(vso);
939 }
940 
941 static struct vxlan_socket *
942 vxlan_socket_lookup(union vxlan_sockaddr *vxlsa)
943 {
944 	struct vxlan_socket *vso;
945 
946 	VXLAN_LIST_LOCK();
947 	LIST_FOREACH(vso, &vxlan_socket_list, vxlso_entry) {
948 		if (vxlan_sockaddr_cmp(&vso->vxlso_laddr, &vxlsa->sa) == 0) {
949 			VXLAN_SO_ACQUIRE(vso);
950 			break;
951 		}
952 	}
953 	VXLAN_LIST_UNLOCK();
954 
955 	return (vso);
956 }
957 
958 static void
959 vxlan_socket_insert(struct vxlan_socket *vso)
960 {
961 
962 	VXLAN_LIST_LOCK();
963 	VXLAN_SO_ACQUIRE(vso);
964 	LIST_INSERT_HEAD(&vxlan_socket_list, vso, vxlso_entry);
965 	VXLAN_LIST_UNLOCK();
966 }
967 
968 static int
969 vxlan_socket_init(struct vxlan_socket *vso, struct ifnet *ifp)
970 {
971 	struct thread *td;
972 	int error;
973 
974 	td = curthread;
975 
976 	error = socreate(vso->vxlso_laddr.sa.sa_family, &vso->vxlso_sock,
977 	    SOCK_DGRAM, IPPROTO_UDP, td->td_ucred, td);
978 	if (error) {
979 		if_printf(ifp, "cannot create socket: %d\n", error);
980 		return (error);
981 	}
982 
983 	error = udp_set_kernel_tunneling(vso->vxlso_sock,
984 	    vxlan_rcv_udp_packet, NULL, vso);
985 	if (error) {
986 		if_printf(ifp, "cannot set tunneling function: %d\n", error);
987 		return (error);
988 	}
989 
990 	if (vxlan_reuse_port != 0) {
991 		struct sockopt sopt;
992 		int val = 1;
993 
994 		bzero(&sopt, sizeof(sopt));
995 		sopt.sopt_dir = SOPT_SET;
996 		sopt.sopt_level = IPPROTO_IP;
997 		sopt.sopt_name = SO_REUSEPORT;
998 		sopt.sopt_val = &val;
999 		sopt.sopt_valsize = sizeof(val);
1000 		error = sosetopt(vso->vxlso_sock, &sopt);
1001 		if (error) {
1002 			if_printf(ifp,
1003 			    "cannot set REUSEADDR socket opt: %d\n", error);
1004 			return (error);
1005 		}
1006 	}
1007 
1008 	return (0);
1009 }
1010 
1011 static int
1012 vxlan_socket_bind(struct vxlan_socket *vso, struct ifnet *ifp)
1013 {
1014 	union vxlan_sockaddr laddr;
1015 	struct thread *td;
1016 	int error;
1017 
1018 	td = curthread;
1019 	laddr = vso->vxlso_laddr;
1020 
1021 	error = sobind(vso->vxlso_sock, &laddr.sa, td);
1022 	if (error) {
1023 		if (error != EADDRINUSE)
1024 			if_printf(ifp, "cannot bind socket: %d\n", error);
1025 		return (error);
1026 	}
1027 
1028 	return (0);
1029 }
1030 
1031 static int
1032 vxlan_socket_create(struct ifnet *ifp, int multicast,
1033     const union vxlan_sockaddr *saddr, struct vxlan_socket **vsop)
1034 {
1035 	union vxlan_sockaddr laddr;
1036 	struct vxlan_socket *vso;
1037 	int error;
1038 
1039 	laddr = *saddr;
1040 
1041 	/*
1042 	 * If this socket will be multicast, then only the local port
1043 	 * must be specified when binding.
1044 	 */
1045 	if (multicast != 0) {
1046 		if (VXLAN_SOCKADDR_IS_IPV4(&laddr))
1047 			laddr.in4.sin_addr.s_addr = INADDR_ANY;
1048 #ifdef INET6
1049 		else
1050 			laddr.in6.sin6_addr = in6addr_any;
1051 #endif
1052 	}
1053 
1054 	vso = vxlan_socket_alloc(&laddr);
1055 	if (vso == NULL)
1056 		return (ENOMEM);
1057 
1058 	error = vxlan_socket_init(vso, ifp);
1059 	if (error)
1060 		goto fail;
1061 
1062 	error = vxlan_socket_bind(vso, ifp);
1063 	if (error)
1064 		goto fail;
1065 
1066 	/*
1067 	 * There is a small window between the bind completing and
1068 	 * inserting the socket, so that a concurrent create may fail.
1069 	 * Let's not worry about that for now.
1070 	 */
1071 	vxlan_socket_insert(vso);
1072 	*vsop = vso;
1073 
1074 	return (0);
1075 
1076 fail:
1077 	vxlan_socket_destroy(vso);
1078 
1079 	return (error);
1080 }
1081 
1082 static void
1083 vxlan_socket_ifdetach(struct vxlan_socket *vso, struct ifnet *ifp,
1084     struct vxlan_softc_head *list)
1085 {
1086 	struct rm_priotracker tracker;
1087 	struct vxlan_softc *sc;
1088 	int i;
1089 
1090 	VXLAN_SO_RLOCK(vso, &tracker);
1091 	for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++) {
1092 		LIST_FOREACH(sc, &vso->vxlso_vni_hash[i], vxl_entry)
1093 			vxlan_ifdetach(sc, ifp, list);
1094 	}
1095 	VXLAN_SO_RUNLOCK(vso, &tracker);
1096 }
1097 
1098 static struct vxlan_socket *
1099 vxlan_socket_mc_lookup(const union vxlan_sockaddr *vxlsa)
1100 {
1101 	union vxlan_sockaddr laddr;
1102 	struct vxlan_socket *vso;
1103 
1104 	laddr = *vxlsa;
1105 
1106 	if (VXLAN_SOCKADDR_IS_IPV4(&laddr))
1107 		laddr.in4.sin_addr.s_addr = INADDR_ANY;
1108 #ifdef INET6
1109 	else
1110 		laddr.in6.sin6_addr = in6addr_any;
1111 #endif
1112 
1113 	vso = vxlan_socket_lookup(&laddr);
1114 
1115 	return (vso);
1116 }
1117 
1118 static int
1119 vxlan_sockaddr_mc_info_match(const struct vxlan_socket_mc_info *mc,
1120     const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1121     int ifidx)
1122 {
1123 
1124 	if (!vxlan_sockaddr_in_any(local) &&
1125 	    !vxlan_sockaddr_in_equal(&mc->vxlsomc_saddr, &local->sa))
1126 		return (0);
1127 	if (!vxlan_sockaddr_in_equal(&mc->vxlsomc_gaddr, &group->sa))
1128 		return (0);
1129 	if (ifidx != 0 && ifidx != mc->vxlsomc_ifidx)
1130 		return (0);
1131 
1132 	return (1);
1133 }
1134 
1135 static int
1136 vxlan_socket_mc_join_group(struct vxlan_socket *vso,
1137     const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1138     int *ifidx, union vxlan_sockaddr *source)
1139 {
1140 	struct sockopt sopt;
1141 	int error;
1142 
1143 	*source = *local;
1144 
1145 	if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1146 		struct ip_mreq mreq;
1147 
1148 		mreq.imr_multiaddr = group->in4.sin_addr;
1149 		mreq.imr_interface = local->in4.sin_addr;
1150 
1151 		bzero(&sopt, sizeof(sopt));
1152 		sopt.sopt_dir = SOPT_SET;
1153 		sopt.sopt_level = IPPROTO_IP;
1154 		sopt.sopt_name = IP_ADD_MEMBERSHIP;
1155 		sopt.sopt_val = &mreq;
1156 		sopt.sopt_valsize = sizeof(mreq);
1157 		error = sosetopt(vso->vxlso_sock, &sopt);
1158 		if (error)
1159 			return (error);
1160 
1161 		/*
1162 		 * BMV: Ideally, there would be a formal way for us to get
1163 		 * the local interface that was selected based on the
1164 		 * imr_interface address. We could then update *ifidx so
1165 		 * vxlan_sockaddr_mc_info_match() would return a match for
1166 		 * later creates that explicitly set the multicast interface.
1167 		 *
1168 		 * If we really need to, we can of course look in the INP's
1169 		 * membership list:
1170 		 *     sotoinpcb(vso->vxlso_sock)->inp_moptions->
1171 		 *         imo_head[]->imf_inm->inm_ifp
1172 		 * similarly to imo_match_group().
1173 		 */
1174 		source->in4.sin_addr = local->in4.sin_addr;
1175 
1176 	} else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1177 		struct ipv6_mreq mreq;
1178 
1179 		mreq.ipv6mr_multiaddr = group->in6.sin6_addr;
1180 		mreq.ipv6mr_interface = *ifidx;
1181 
1182 		bzero(&sopt, sizeof(sopt));
1183 		sopt.sopt_dir = SOPT_SET;
1184 		sopt.sopt_level = IPPROTO_IPV6;
1185 		sopt.sopt_name = IPV6_JOIN_GROUP;
1186 		sopt.sopt_val = &mreq;
1187 		sopt.sopt_valsize = sizeof(mreq);
1188 		error = sosetopt(vso->vxlso_sock, &sopt);
1189 		if (error)
1190 			return (error);
1191 
1192 		/*
1193 		 * BMV: As with IPv4, we would really like to know what
1194 		 * interface in6p_lookup_mcast_ifp() selected.
1195 		 */
1196 	} else
1197 		error = EAFNOSUPPORT;
1198 
1199 	return (error);
1200 }
1201 
1202 static int
1203 vxlan_socket_mc_leave_group(struct vxlan_socket *vso,
1204     const union vxlan_sockaddr *group, const union vxlan_sockaddr *source,
1205     int ifidx)
1206 {
1207 	struct sockopt sopt;
1208 	int error;
1209 
1210 	bzero(&sopt, sizeof(sopt));
1211 	sopt.sopt_dir = SOPT_SET;
1212 
1213 	if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1214 		struct ip_mreq mreq;
1215 
1216 		mreq.imr_multiaddr = group->in4.sin_addr;
1217 		mreq.imr_interface = source->in4.sin_addr;
1218 
1219 		sopt.sopt_level = IPPROTO_IP;
1220 		sopt.sopt_name = IP_DROP_MEMBERSHIP;
1221 		sopt.sopt_val = &mreq;
1222 		sopt.sopt_valsize = sizeof(mreq);
1223 		error = sosetopt(vso->vxlso_sock, &sopt);
1224 
1225 	} else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1226 		struct ipv6_mreq mreq;
1227 
1228 		mreq.ipv6mr_multiaddr = group->in6.sin6_addr;
1229 		mreq.ipv6mr_interface = ifidx;
1230 
1231 		sopt.sopt_level = IPPROTO_IPV6;
1232 		sopt.sopt_name = IPV6_LEAVE_GROUP;
1233 		sopt.sopt_val = &mreq;
1234 		sopt.sopt_valsize = sizeof(mreq);
1235 		error = sosetopt(vso->vxlso_sock, &sopt);
1236 
1237 	} else
1238 		error = EAFNOSUPPORT;
1239 
1240 	return (error);
1241 }
1242 
1243 static int
1244 vxlan_socket_mc_add_group(struct vxlan_socket *vso,
1245     const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1246     int ifidx, int *idx)
1247 {
1248 	union vxlan_sockaddr source;
1249 	struct vxlan_socket_mc_info *mc;
1250 	int i, empty, error;
1251 
1252 	/*
1253 	 * Within a socket, the same multicast group may be used by multiple
1254 	 * interfaces, each with a different network identifier. But a socket
1255 	 * may only join a multicast group once, so keep track of the users
1256 	 * here.
1257 	 */
1258 
1259 	VXLAN_SO_WLOCK(vso);
1260 	for (empty = 0, i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
1261 		mc = &vso->vxlso_mc[i];
1262 
1263 		if (mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC) {
1264 			empty++;
1265 			continue;
1266 		}
1267 
1268 		if (vxlan_sockaddr_mc_info_match(mc, group, local, ifidx))
1269 			goto out;
1270 	}
1271 	VXLAN_SO_WUNLOCK(vso);
1272 
1273 	if (empty == 0)
1274 		return (ENOSPC);
1275 
1276 	error = vxlan_socket_mc_join_group(vso, group, local, &ifidx, &source);
1277 	if (error)
1278 		return (error);
1279 
1280 	VXLAN_SO_WLOCK(vso);
1281 	for (i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
1282 		mc = &vso->vxlso_mc[i];
1283 
1284 		if (mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC) {
1285 			vxlan_sockaddr_copy(&mc->vxlsomc_gaddr, &group->sa);
1286 			vxlan_sockaddr_copy(&mc->vxlsomc_saddr, &source.sa);
1287 			mc->vxlsomc_ifidx = ifidx;
1288 			goto out;
1289 		}
1290 	}
1291 	VXLAN_SO_WUNLOCK(vso);
1292 
1293 	error = vxlan_socket_mc_leave_group(vso, group, &source, ifidx);
1294 	MPASS(error == 0);
1295 
1296 	return (ENOSPC);
1297 
1298 out:
1299 	mc->vxlsomc_users++;
1300 	VXLAN_SO_WUNLOCK(vso);
1301 
1302 	*idx = i;
1303 
1304 	return (0);
1305 }
1306 
1307 static void
1308 vxlan_socket_mc_release_group_by_idx(struct vxlan_socket *vso, int idx)
1309 {
1310 	union vxlan_sockaddr group, source;
1311 	struct vxlan_socket_mc_info *mc;
1312 	int ifidx, leave;
1313 
1314 	KASSERT(idx >= 0 && idx < VXLAN_SO_MC_MAX_GROUPS,
1315 	    ("%s: vso %p idx %d out of bounds", __func__, vso, idx));
1316 
1317 	leave = 0;
1318 	mc = &vso->vxlso_mc[idx];
1319 
1320 	VXLAN_SO_WLOCK(vso);
1321 	mc->vxlsomc_users--;
1322 	if (mc->vxlsomc_users == 0) {
1323 		group = mc->vxlsomc_gaddr;
1324 		source = mc->vxlsomc_saddr;
1325 		ifidx = mc->vxlsomc_ifidx;
1326 		bzero(mc, sizeof(*mc));
1327 		leave = 1;
1328 	}
1329 	VXLAN_SO_WUNLOCK(vso);
1330 
1331 	if (leave != 0) {
1332 		/*
1333 		 * Our socket's membership in this group may have already
1334 		 * been removed if we joined through an interface that's
1335 		 * been detached.
1336 		 */
1337 		vxlan_socket_mc_leave_group(vso, &group, &source, ifidx);
1338 	}
1339 }
1340 
1341 static struct vxlan_softc *
1342 vxlan_socket_lookup_softc_locked(struct vxlan_socket *vso, uint32_t vni)
1343 {
1344 	struct vxlan_softc *sc;
1345 	uint32_t hash;
1346 
1347 	VXLAN_SO_LOCK_ASSERT(vso);
1348 	hash = VXLAN_SO_VNI_HASH(vni);
1349 
1350 	LIST_FOREACH(sc, &vso->vxlso_vni_hash[hash], vxl_entry) {
1351 		if (sc->vxl_vni == vni) {
1352 			VXLAN_ACQUIRE(sc);
1353 			break;
1354 		}
1355 	}
1356 
1357 	return (sc);
1358 }
1359 
1360 static struct vxlan_softc *
1361 vxlan_socket_lookup_softc(struct vxlan_socket *vso, uint32_t vni)
1362 {
1363 	struct rm_priotracker tracker;
1364 	struct vxlan_softc *sc;
1365 
1366 	VXLAN_SO_RLOCK(vso, &tracker);
1367 	sc = vxlan_socket_lookup_softc_locked(vso, vni);
1368 	VXLAN_SO_RUNLOCK(vso, &tracker);
1369 
1370 	return (sc);
1371 }
1372 
1373 static int
1374 vxlan_socket_insert_softc(struct vxlan_socket *vso, struct vxlan_softc *sc)
1375 {
1376 	struct vxlan_softc *tsc;
1377 	uint32_t vni, hash;
1378 
1379 	vni = sc->vxl_vni;
1380 	hash = VXLAN_SO_VNI_HASH(vni);
1381 
1382 	VXLAN_SO_WLOCK(vso);
1383 	tsc = vxlan_socket_lookup_softc_locked(vso, vni);
1384 	if (tsc != NULL) {
1385 		VXLAN_SO_WUNLOCK(vso);
1386 		vxlan_release(tsc);
1387 		return (EEXIST);
1388 	}
1389 
1390 	VXLAN_ACQUIRE(sc);
1391 	LIST_INSERT_HEAD(&vso->vxlso_vni_hash[hash], sc, vxl_entry);
1392 	VXLAN_SO_WUNLOCK(vso);
1393 
1394 	return (0);
1395 }
1396 
1397 static void
1398 vxlan_socket_remove_softc(struct vxlan_socket *vso, struct vxlan_softc *sc)
1399 {
1400 
1401 	VXLAN_SO_WLOCK(vso);
1402 	LIST_REMOVE(sc, vxl_entry);
1403 	VXLAN_SO_WUNLOCK(vso);
1404 
1405 	vxlan_release(sc);
1406 }
1407 
1408 static struct ifnet *
1409 vxlan_multicast_if_ref(struct vxlan_softc *sc, int ipv4)
1410 {
1411 	struct ifnet *ifp;
1412 
1413 	VXLAN_LOCK_ASSERT(sc);
1414 
1415 	if (ipv4 && sc->vxl_im4o != NULL)
1416 		ifp = sc->vxl_im4o->imo_multicast_ifp;
1417 	else if (!ipv4 && sc->vxl_im6o != NULL)
1418 		ifp = sc->vxl_im6o->im6o_multicast_ifp;
1419 	else
1420 		ifp = NULL;
1421 
1422 	if (ifp != NULL)
1423 		if_ref(ifp);
1424 
1425 	return (ifp);
1426 }
1427 
1428 static void
1429 vxlan_free_multicast(struct vxlan_softc *sc)
1430 {
1431 
1432 	if (sc->vxl_mc_ifp != NULL) {
1433 		if_rele(sc->vxl_mc_ifp);
1434 		sc->vxl_mc_ifp = NULL;
1435 		sc->vxl_mc_ifindex = 0;
1436 	}
1437 
1438 	if (sc->vxl_im4o != NULL) {
1439 		free(sc->vxl_im4o, M_VXLAN);
1440 		sc->vxl_im4o = NULL;
1441 	}
1442 
1443 	if (sc->vxl_im6o != NULL) {
1444 		free(sc->vxl_im6o, M_VXLAN);
1445 		sc->vxl_im6o = NULL;
1446 	}
1447 }
1448 
1449 static int
1450 vxlan_setup_multicast_interface(struct vxlan_softc *sc)
1451 {
1452 	struct ifnet *ifp;
1453 
1454 	ifp = ifunit_ref(sc->vxl_mc_ifname);
1455 	if (ifp == NULL) {
1456 		if_printf(sc->vxl_ifp, "multicast interface %s does "
1457 		    "not exist\n", sc->vxl_mc_ifname);
1458 		return (ENOENT);
1459 	}
1460 
1461 	if ((ifp->if_flags & IFF_MULTICAST) == 0) {
1462 		if_printf(sc->vxl_ifp, "interface %s does not support "
1463 		     "multicast\n", sc->vxl_mc_ifname);
1464 		if_rele(ifp);
1465 		return (ENOTSUP);
1466 	}
1467 
1468 	sc->vxl_mc_ifp = ifp;
1469 	sc->vxl_mc_ifindex = ifp->if_index;
1470 
1471 	return (0);
1472 }
1473 
1474 static int
1475 vxlan_setup_multicast(struct vxlan_softc *sc)
1476 {
1477 	const union vxlan_sockaddr *group;
1478 	int error;
1479 
1480 	group = &sc->vxl_dst_addr;
1481 	error = 0;
1482 
1483 	if (sc->vxl_mc_ifname[0] != '\0') {
1484 		error = vxlan_setup_multicast_interface(sc);
1485 		if (error)
1486 			return (error);
1487 	}
1488 
1489 	/*
1490 	 * Initialize an multicast options structure that is sufficiently
1491 	 * populated for use in the respective IP output routine. This
1492 	 * structure is typically stored in the socket, but our sockets
1493 	 * may be shared among multiple interfaces.
1494 	 */
1495 	if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1496 		sc->vxl_im4o = malloc(sizeof(struct ip_moptions), M_VXLAN,
1497 		    M_ZERO | M_WAITOK);
1498 		sc->vxl_im4o->imo_multicast_ifp = sc->vxl_mc_ifp;
1499 		sc->vxl_im4o->imo_multicast_ttl = sc->vxl_ttl;
1500 		sc->vxl_im4o->imo_multicast_vif = -1;
1501 	} else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1502 		sc->vxl_im6o = malloc(sizeof(struct ip6_moptions), M_VXLAN,
1503 		    M_ZERO | M_WAITOK);
1504 		sc->vxl_im6o->im6o_multicast_ifp = sc->vxl_mc_ifp;
1505 		sc->vxl_im6o->im6o_multicast_hlim = sc->vxl_ttl;
1506 	}
1507 
1508 	return (error);
1509 }
1510 
1511 static int
1512 vxlan_setup_socket(struct vxlan_softc *sc)
1513 {
1514 	struct vxlan_socket *vso;
1515 	struct ifnet *ifp;
1516 	union vxlan_sockaddr *saddr, *daddr;
1517 	int multicast, error;
1518 
1519 	vso = NULL;
1520 	ifp = sc->vxl_ifp;
1521 	saddr = &sc->vxl_src_addr;
1522 	daddr = &sc->vxl_dst_addr;
1523 
1524 	multicast = vxlan_sockaddr_in_multicast(daddr);
1525 	MPASS(multicast != -1);
1526 	sc->vxl_vso_mc_index = -1;
1527 
1528 	/*
1529 	 * Try to create the socket. If that fails, attempt to use an
1530 	 * existing socket.
1531 	 */
1532 	error = vxlan_socket_create(ifp, multicast, saddr, &vso);
1533 	if (error) {
1534 		if (multicast != 0)
1535 			vso = vxlan_socket_mc_lookup(saddr);
1536 		else
1537 			vso = vxlan_socket_lookup(saddr);
1538 
1539 		if (vso == NULL) {
1540 			if_printf(ifp, "cannot create socket (error: %d), "
1541 			    "and no existing socket found\n", error);
1542 			goto out;
1543 		}
1544 	}
1545 
1546 	if (multicast != 0) {
1547 		error = vxlan_setup_multicast(sc);
1548 		if (error)
1549 			goto out;
1550 
1551 		error = vxlan_socket_mc_add_group(vso, daddr, saddr,
1552 		    sc->vxl_mc_ifindex, &sc->vxl_vso_mc_index);
1553 		if (error)
1554 			goto out;
1555 	}
1556 
1557 	sc->vxl_sock = vso;
1558 	error = vxlan_socket_insert_softc(vso, sc);
1559 	if (error) {
1560 		sc->vxl_sock = NULL;
1561 		if_printf(ifp, "network identifier %d already exists in "
1562 		    "this socket\n", sc->vxl_vni);
1563 		goto out;
1564 	}
1565 
1566 	return (0);
1567 
1568 out:
1569 	if (vso != NULL) {
1570 		if (sc->vxl_vso_mc_index != -1) {
1571 			vxlan_socket_mc_release_group_by_idx(vso,
1572 			    sc->vxl_vso_mc_index);
1573 			sc->vxl_vso_mc_index = -1;
1574 		}
1575 		if (multicast != 0)
1576 			vxlan_free_multicast(sc);
1577 		vxlan_socket_release(vso);
1578 	}
1579 
1580 	return (error);
1581 }
1582 
1583 #ifdef INET6
1584 static void
1585 vxlan_setup_zero_checksum_port(struct vxlan_softc *sc)
1586 {
1587 
1588 	if (!VXLAN_SOCKADDR_IS_IPV6(&sc->vxl_src_addr))
1589 		return;
1590 
1591 	MPASS(sc->vxl_src_addr.in6.sin6_port != 0);
1592 	MPASS(sc->vxl_dst_addr.in6.sin6_port != 0);
1593 
1594 	if (sc->vxl_src_addr.in6.sin6_port != sc->vxl_dst_addr.in6.sin6_port) {
1595 		if_printf(sc->vxl_ifp, "port %d in src address does not match "
1596 		    "port %d in dst address, rfc6935_port (%d) not updated.\n",
1597 		    ntohs(sc->vxl_src_addr.in6.sin6_port),
1598 		    ntohs(sc->vxl_dst_addr.in6.sin6_port),
1599 		    V_zero_checksum_port);
1600 		return;
1601 	}
1602 
1603 	if (V_zero_checksum_port != 0) {
1604 		if (V_zero_checksum_port !=
1605 		    ntohs(sc->vxl_src_addr.in6.sin6_port)) {
1606 			if_printf(sc->vxl_ifp, "rfc6935_port is already set to "
1607 			    "%d, cannot set it to %d.\n", V_zero_checksum_port,
1608 			    ntohs(sc->vxl_src_addr.in6.sin6_port));
1609 		}
1610 		return;
1611 	}
1612 
1613 	V_zero_checksum_port = ntohs(sc->vxl_src_addr.in6.sin6_port);
1614 	if_printf(sc->vxl_ifp, "rfc6935_port set to %d\n",
1615 	    V_zero_checksum_port);
1616 }
1617 #endif
1618 
1619 static void
1620 vxlan_setup_interface_hdrlen(struct vxlan_softc *sc)
1621 {
1622 	struct ifnet *ifp;
1623 
1624 	VXLAN_LOCK_WASSERT(sc);
1625 
1626 	ifp = sc->vxl_ifp;
1627 	ifp->if_hdrlen = ETHER_HDR_LEN + sizeof(struct vxlanudphdr);
1628 
1629 	if (VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_dst_addr) != 0)
1630 		ifp->if_hdrlen += sizeof(struct ip);
1631 	else if (VXLAN_SOCKADDR_IS_IPV6(&sc->vxl_dst_addr) != 0)
1632 		ifp->if_hdrlen += sizeof(struct ip6_hdr);
1633 
1634 	if ((sc->vxl_flags & VXLAN_FLAG_USER_MTU) == 0)
1635 		ifp->if_mtu = ETHERMTU - ifp->if_hdrlen;
1636 }
1637 
1638 static int
1639 vxlan_valid_init_config(struct vxlan_softc *sc)
1640 {
1641 	const char *reason;
1642 
1643 	if (vxlan_check_vni(sc->vxl_vni) != 0) {
1644 		reason = "invalid virtual network identifier specified";
1645 		goto fail;
1646 	}
1647 
1648 	if (vxlan_sockaddr_supported(&sc->vxl_src_addr, 1) == 0) {
1649 		reason = "source address type is not supported";
1650 		goto fail;
1651 	}
1652 
1653 	if (vxlan_sockaddr_supported(&sc->vxl_dst_addr, 0) == 0) {
1654 		reason = "destination address type is not supported";
1655 		goto fail;
1656 	}
1657 
1658 	if (vxlan_sockaddr_in_any(&sc->vxl_dst_addr) != 0) {
1659 		reason = "no valid destination address specified";
1660 		goto fail;
1661 	}
1662 
1663 	if (vxlan_sockaddr_in_multicast(&sc->vxl_dst_addr) == 0 &&
1664 	    sc->vxl_mc_ifname[0] != '\0') {
1665 		reason = "can only specify interface with a group address";
1666 		goto fail;
1667 	}
1668 
1669 	if (vxlan_sockaddr_in_any(&sc->vxl_src_addr) == 0) {
1670 		if (VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_src_addr) ^
1671 		    VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_dst_addr)) {
1672 			reason = "source and destination address must both "
1673 			    "be either IPv4 or IPv6";
1674 			goto fail;
1675 		}
1676 	}
1677 
1678 	if (sc->vxl_src_addr.in4.sin_port == 0) {
1679 		reason = "local port not specified";
1680 		goto fail;
1681 	}
1682 
1683 	if (sc->vxl_dst_addr.in4.sin_port == 0) {
1684 		reason = "remote port not specified";
1685 		goto fail;
1686 	}
1687 
1688 	return (0);
1689 
1690 fail:
1691 	if_printf(sc->vxl_ifp, "cannot initialize interface: %s\n", reason);
1692 	return (EINVAL);
1693 }
1694 
1695 static void
1696 vxlan_init_wait(struct vxlan_softc *sc)
1697 {
1698 
1699 	VXLAN_LOCK_WASSERT(sc);
1700 	while (sc->vxl_flags & VXLAN_FLAG_INIT)
1701 		rm_sleep(sc, &sc->vxl_lock, 0, "vxlint", hz);
1702 }
1703 
1704 static void
1705 vxlan_init_complete(struct vxlan_softc *sc)
1706 {
1707 
1708 	VXLAN_WLOCK(sc);
1709 	sc->vxl_flags &= ~VXLAN_FLAG_INIT;
1710 	wakeup(sc);
1711 	VXLAN_WUNLOCK(sc);
1712 }
1713 
1714 static void
1715 vxlan_init(void *xsc)
1716 {
1717 	static const uint8_t empty_mac[ETHER_ADDR_LEN];
1718 	struct vxlan_softc *sc;
1719 	struct ifnet *ifp;
1720 
1721 	sc = xsc;
1722 	ifp = sc->vxl_ifp;
1723 
1724 	sx_xlock(&vxlan_sx);
1725 	VXLAN_WLOCK(sc);
1726 	if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1727 		VXLAN_WUNLOCK(sc);
1728 		sx_xunlock(&vxlan_sx);
1729 		return;
1730 	}
1731 	sc->vxl_flags |= VXLAN_FLAG_INIT;
1732 	VXLAN_WUNLOCK(sc);
1733 
1734 	if (vxlan_valid_init_config(sc) != 0)
1735 		goto out;
1736 
1737 	if (vxlan_setup_socket(sc) != 0)
1738 		goto out;
1739 
1740 #ifdef INET6
1741 	vxlan_setup_zero_checksum_port(sc);
1742 #endif
1743 
1744 	/* Initialize the default forwarding entry. */
1745 	vxlan_ftable_entry_init(sc, &sc->vxl_default_fe, empty_mac,
1746 	    &sc->vxl_dst_addr.sa, VXLAN_FE_FLAG_STATIC);
1747 
1748 	VXLAN_WLOCK(sc);
1749 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
1750 	callout_reset(&sc->vxl_callout, vxlan_ftable_prune_period * hz,
1751 	    vxlan_timer, sc);
1752 	VXLAN_WUNLOCK(sc);
1753 
1754 	if_link_state_change(ifp, LINK_STATE_UP);
1755 
1756 	EVENTHANDLER_INVOKE(vxlan_start, ifp, sc->vxl_src_addr.in4.sin_family,
1757 	    ntohs(sc->vxl_src_addr.in4.sin_port));
1758 out:
1759 	vxlan_init_complete(sc);
1760 	sx_xunlock(&vxlan_sx);
1761 }
1762 
1763 static void
1764 vxlan_release(struct vxlan_softc *sc)
1765 {
1766 
1767 	/*
1768 	 * The softc may be destroyed as soon as we release our reference,
1769 	 * so we cannot serialize the wakeup with the softc lock. We use a
1770 	 * timeout in our sleeps so a missed wakeup is unfortunate but not
1771 	 * fatal.
1772 	 */
1773 	if (VXLAN_RELEASE(sc) != 0)
1774 		wakeup(sc);
1775 }
1776 
1777 static void
1778 vxlan_teardown_wait(struct vxlan_softc *sc)
1779 {
1780 
1781 	VXLAN_LOCK_WASSERT(sc);
1782 	while (sc->vxl_flags & VXLAN_FLAG_TEARDOWN)
1783 		rm_sleep(sc, &sc->vxl_lock, 0, "vxltrn", hz);
1784 }
1785 
1786 static void
1787 vxlan_teardown_complete(struct vxlan_softc *sc)
1788 {
1789 
1790 	VXLAN_WLOCK(sc);
1791 	sc->vxl_flags &= ~VXLAN_FLAG_TEARDOWN;
1792 	wakeup(sc);
1793 	VXLAN_WUNLOCK(sc);
1794 }
1795 
1796 static void
1797 vxlan_teardown_locked(struct vxlan_softc *sc)
1798 {
1799 	struct ifnet *ifp;
1800 	struct vxlan_socket *vso;
1801 
1802 	sx_assert(&vxlan_sx, SA_XLOCKED);
1803 	VXLAN_LOCK_WASSERT(sc);
1804 	MPASS(sc->vxl_flags & VXLAN_FLAG_TEARDOWN);
1805 
1806 	ifp = sc->vxl_ifp;
1807 	ifp->if_flags &= ~IFF_UP;
1808 	ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1809 	callout_stop(&sc->vxl_callout);
1810 	vso = sc->vxl_sock;
1811 	sc->vxl_sock = NULL;
1812 
1813 	VXLAN_WUNLOCK(sc);
1814 	if_link_state_change(ifp, LINK_STATE_DOWN);
1815 	EVENTHANDLER_INVOKE(vxlan_stop, ifp, sc->vxl_src_addr.in4.sin_family,
1816 	    ntohs(sc->vxl_src_addr.in4.sin_port));
1817 
1818 	if (vso != NULL) {
1819 		vxlan_socket_remove_softc(vso, sc);
1820 
1821 		if (sc->vxl_vso_mc_index != -1) {
1822 			vxlan_socket_mc_release_group_by_idx(vso,
1823 			    sc->vxl_vso_mc_index);
1824 			sc->vxl_vso_mc_index = -1;
1825 		}
1826 	}
1827 
1828 	VXLAN_WLOCK(sc);
1829 	while (sc->vxl_refcnt != 0)
1830 		rm_sleep(sc, &sc->vxl_lock, 0, "vxldrn", hz);
1831 	VXLAN_WUNLOCK(sc);
1832 
1833 	callout_drain(&sc->vxl_callout);
1834 
1835 	vxlan_free_multicast(sc);
1836 	if (vso != NULL)
1837 		vxlan_socket_release(vso);
1838 
1839 	vxlan_teardown_complete(sc);
1840 }
1841 
1842 static void
1843 vxlan_teardown(struct vxlan_softc *sc)
1844 {
1845 
1846 	sx_xlock(&vxlan_sx);
1847 	VXLAN_WLOCK(sc);
1848 	if (sc->vxl_flags & VXLAN_FLAG_TEARDOWN) {
1849 		vxlan_teardown_wait(sc);
1850 		VXLAN_WUNLOCK(sc);
1851 		sx_xunlock(&vxlan_sx);
1852 		return;
1853 	}
1854 
1855 	sc->vxl_flags |= VXLAN_FLAG_TEARDOWN;
1856 	vxlan_teardown_locked(sc);
1857 	sx_xunlock(&vxlan_sx);
1858 }
1859 
1860 static void
1861 vxlan_ifdetach(struct vxlan_softc *sc, struct ifnet *ifp,
1862     struct vxlan_softc_head *list)
1863 {
1864 
1865 	VXLAN_WLOCK(sc);
1866 
1867 	if (sc->vxl_mc_ifp != ifp)
1868 		goto out;
1869 	if (sc->vxl_flags & VXLAN_FLAG_TEARDOWN)
1870 		goto out;
1871 
1872 	sc->vxl_flags |= VXLAN_FLAG_TEARDOWN;
1873 	LIST_INSERT_HEAD(list, sc, vxl_ifdetach_list);
1874 
1875 out:
1876 	VXLAN_WUNLOCK(sc);
1877 }
1878 
1879 static void
1880 vxlan_timer(void *xsc)
1881 {
1882 	struct vxlan_softc *sc;
1883 
1884 	sc = xsc;
1885 	VXLAN_LOCK_WASSERT(sc);
1886 
1887 	vxlan_ftable_expire(sc);
1888 	callout_schedule(&sc->vxl_callout, vxlan_ftable_prune_period * hz);
1889 }
1890 
1891 static int
1892 vxlan_ioctl_ifflags(struct vxlan_softc *sc)
1893 {
1894 	struct ifnet *ifp;
1895 
1896 	ifp = sc->vxl_ifp;
1897 
1898 	if (ifp->if_flags & IFF_UP) {
1899 		if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1900 			vxlan_init(sc);
1901 	} else {
1902 		if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1903 			vxlan_teardown(sc);
1904 	}
1905 
1906 	return (0);
1907 }
1908 
1909 static int
1910 vxlan_ctrl_get_config(struct vxlan_softc *sc, void *arg)
1911 {
1912 	struct rm_priotracker tracker;
1913 	struct ifvxlancfg *cfg;
1914 
1915 	cfg = arg;
1916 	bzero(cfg, sizeof(*cfg));
1917 
1918 	VXLAN_RLOCK(sc, &tracker);
1919 	cfg->vxlc_vni = sc->vxl_vni;
1920 	memcpy(&cfg->vxlc_local_sa, &sc->vxl_src_addr,
1921 	    sizeof(union vxlan_sockaddr));
1922 	memcpy(&cfg->vxlc_remote_sa, &sc->vxl_dst_addr,
1923 	    sizeof(union vxlan_sockaddr));
1924 	cfg->vxlc_mc_ifindex = sc->vxl_mc_ifindex;
1925 	cfg->vxlc_ftable_cnt = sc->vxl_ftable_cnt;
1926 	cfg->vxlc_ftable_max = sc->vxl_ftable_max;
1927 	cfg->vxlc_ftable_timeout = sc->vxl_ftable_timeout;
1928 	cfg->vxlc_port_min = sc->vxl_min_port;
1929 	cfg->vxlc_port_max = sc->vxl_max_port;
1930 	cfg->vxlc_learn = (sc->vxl_flags & VXLAN_FLAG_LEARN) != 0;
1931 	cfg->vxlc_ttl = sc->vxl_ttl;
1932 	VXLAN_RUNLOCK(sc, &tracker);
1933 
1934 #ifdef INET6
1935 	if (VXLAN_SOCKADDR_IS_IPV6(&cfg->vxlc_local_sa))
1936 		sa6_recoverscope(&cfg->vxlc_local_sa.in6);
1937 	if (VXLAN_SOCKADDR_IS_IPV6(&cfg->vxlc_remote_sa))
1938 		sa6_recoverscope(&cfg->vxlc_remote_sa.in6);
1939 #endif
1940 
1941 	return (0);
1942 }
1943 
1944 static int
1945 vxlan_ctrl_set_vni(struct vxlan_softc *sc, void *arg)
1946 {
1947 	struct ifvxlancmd *cmd;
1948 	int error;
1949 
1950 	cmd = arg;
1951 
1952 	if (vxlan_check_vni(cmd->vxlcmd_vni) != 0)
1953 		return (EINVAL);
1954 
1955 	VXLAN_WLOCK(sc);
1956 	if (vxlan_can_change_config(sc)) {
1957 		sc->vxl_vni = cmd->vxlcmd_vni;
1958 		error = 0;
1959 	} else
1960 		error = EBUSY;
1961 	VXLAN_WUNLOCK(sc);
1962 
1963 	return (error);
1964 }
1965 
1966 static int
1967 vxlan_ctrl_set_local_addr(struct vxlan_softc *sc, void *arg)
1968 {
1969 	struct ifvxlancmd *cmd;
1970 	union vxlan_sockaddr *vxlsa;
1971 	int error;
1972 
1973 	cmd = arg;
1974 	vxlsa = &cmd->vxlcmd_sa;
1975 
1976 	if (!VXLAN_SOCKADDR_IS_IPV46(vxlsa))
1977 		return (EINVAL);
1978 	if (vxlan_sockaddr_in_multicast(vxlsa) != 0)
1979 		return (EINVAL);
1980 	if (VXLAN_SOCKADDR_IS_IPV6(vxlsa)) {
1981 		error = vxlan_sockaddr_in6_embedscope(vxlsa);
1982 		if (error)
1983 			return (error);
1984 	}
1985 
1986 	VXLAN_WLOCK(sc);
1987 	if (vxlan_can_change_config(sc)) {
1988 		vxlan_sockaddr_in_copy(&sc->vxl_src_addr, &vxlsa->sa);
1989 		vxlan_set_hwcaps(sc);
1990 		error = 0;
1991 	} else
1992 		error = EBUSY;
1993 	VXLAN_WUNLOCK(sc);
1994 
1995 	return (error);
1996 }
1997 
1998 static int
1999 vxlan_ctrl_set_remote_addr(struct vxlan_softc *sc, void *arg)
2000 {
2001 	struct ifvxlancmd *cmd;
2002 	union vxlan_sockaddr *vxlsa;
2003 	int error;
2004 
2005 	cmd = arg;
2006 	vxlsa = &cmd->vxlcmd_sa;
2007 
2008 	if (!VXLAN_SOCKADDR_IS_IPV46(vxlsa))
2009 		return (EINVAL);
2010 	if (VXLAN_SOCKADDR_IS_IPV6(vxlsa)) {
2011 		error = vxlan_sockaddr_in6_embedscope(vxlsa);
2012 		if (error)
2013 			return (error);
2014 	}
2015 
2016 	VXLAN_WLOCK(sc);
2017 	if (vxlan_can_change_config(sc)) {
2018 		vxlan_sockaddr_in_copy(&sc->vxl_dst_addr, &vxlsa->sa);
2019 		vxlan_setup_interface_hdrlen(sc);
2020 		error = 0;
2021 	} else
2022 		error = EBUSY;
2023 	VXLAN_WUNLOCK(sc);
2024 
2025 	return (error);
2026 }
2027 
2028 static int
2029 vxlan_ctrl_set_local_port(struct vxlan_softc *sc, void *arg)
2030 {
2031 	struct ifvxlancmd *cmd;
2032 	int error;
2033 
2034 	cmd = arg;
2035 
2036 	if (cmd->vxlcmd_port == 0)
2037 		return (EINVAL);
2038 
2039 	VXLAN_WLOCK(sc);
2040 	if (vxlan_can_change_config(sc)) {
2041 		sc->vxl_src_addr.in4.sin_port = htons(cmd->vxlcmd_port);
2042 		error = 0;
2043 	} else
2044 		error = EBUSY;
2045 	VXLAN_WUNLOCK(sc);
2046 
2047 	return (error);
2048 }
2049 
2050 static int
2051 vxlan_ctrl_set_remote_port(struct vxlan_softc *sc, void *arg)
2052 {
2053 	struct ifvxlancmd *cmd;
2054 	int error;
2055 
2056 	cmd = arg;
2057 
2058 	if (cmd->vxlcmd_port == 0)
2059 		return (EINVAL);
2060 
2061 	VXLAN_WLOCK(sc);
2062 	if (vxlan_can_change_config(sc)) {
2063 		sc->vxl_dst_addr.in4.sin_port = htons(cmd->vxlcmd_port);
2064 		error = 0;
2065 	} else
2066 		error = EBUSY;
2067 	VXLAN_WUNLOCK(sc);
2068 
2069 	return (error);
2070 }
2071 
2072 static int
2073 vxlan_ctrl_set_port_range(struct vxlan_softc *sc, void *arg)
2074 {
2075 	struct ifvxlancmd *cmd;
2076 	uint16_t min, max;
2077 	int error;
2078 
2079 	cmd = arg;
2080 	min = cmd->vxlcmd_port_min;
2081 	max = cmd->vxlcmd_port_max;
2082 
2083 	if (max < min)
2084 		return (EINVAL);
2085 
2086 	VXLAN_WLOCK(sc);
2087 	if (vxlan_can_change_config(sc)) {
2088 		sc->vxl_min_port = min;
2089 		sc->vxl_max_port = max;
2090 		error = 0;
2091 	} else
2092 		error = EBUSY;
2093 	VXLAN_WUNLOCK(sc);
2094 
2095 	return (error);
2096 }
2097 
2098 static int
2099 vxlan_ctrl_set_ftable_timeout(struct vxlan_softc *sc, void *arg)
2100 {
2101 	struct ifvxlancmd *cmd;
2102 	int error;
2103 
2104 	cmd = arg;
2105 
2106 	VXLAN_WLOCK(sc);
2107 	if (vxlan_check_ftable_timeout(cmd->vxlcmd_ftable_timeout) == 0) {
2108 		sc->vxl_ftable_timeout = cmd->vxlcmd_ftable_timeout;
2109 		error = 0;
2110 	} else
2111 		error = EINVAL;
2112 	VXLAN_WUNLOCK(sc);
2113 
2114 	return (error);
2115 }
2116 
2117 static int
2118 vxlan_ctrl_set_ftable_max(struct vxlan_softc *sc, void *arg)
2119 {
2120 	struct ifvxlancmd *cmd;
2121 	int error;
2122 
2123 	cmd = arg;
2124 
2125 	VXLAN_WLOCK(sc);
2126 	if (vxlan_check_ftable_max(cmd->vxlcmd_ftable_max) == 0) {
2127 		sc->vxl_ftable_max = cmd->vxlcmd_ftable_max;
2128 		error = 0;
2129 	} else
2130 		error = EINVAL;
2131 	VXLAN_WUNLOCK(sc);
2132 
2133 	return (error);
2134 }
2135 
2136 static int
2137 vxlan_ctrl_set_multicast_if(struct vxlan_softc * sc, void *arg)
2138 {
2139 	struct ifvxlancmd *cmd;
2140 	int error;
2141 
2142 	cmd = arg;
2143 
2144 	VXLAN_WLOCK(sc);
2145 	if (vxlan_can_change_config(sc)) {
2146 		strlcpy(sc->vxl_mc_ifname, cmd->vxlcmd_ifname, IFNAMSIZ);
2147 		vxlan_set_hwcaps(sc);
2148 		error = 0;
2149 	} else
2150 		error = EBUSY;
2151 	VXLAN_WUNLOCK(sc);
2152 
2153 	return (error);
2154 }
2155 
2156 static int
2157 vxlan_ctrl_set_ttl(struct vxlan_softc *sc, void *arg)
2158 {
2159 	struct ifvxlancmd *cmd;
2160 	int error;
2161 
2162 	cmd = arg;
2163 
2164 	VXLAN_WLOCK(sc);
2165 	if (vxlan_check_ttl(cmd->vxlcmd_ttl) == 0) {
2166 		sc->vxl_ttl = cmd->vxlcmd_ttl;
2167 		if (sc->vxl_im4o != NULL)
2168 			sc->vxl_im4o->imo_multicast_ttl = sc->vxl_ttl;
2169 		if (sc->vxl_im6o != NULL)
2170 			sc->vxl_im6o->im6o_multicast_hlim = sc->vxl_ttl;
2171 		error = 0;
2172 	} else
2173 		error = EINVAL;
2174 	VXLAN_WUNLOCK(sc);
2175 
2176 	return (error);
2177 }
2178 
2179 static int
2180 vxlan_ctrl_set_learn(struct vxlan_softc *sc, void *arg)
2181 {
2182 	struct ifvxlancmd *cmd;
2183 
2184 	cmd = arg;
2185 
2186 	VXLAN_WLOCK(sc);
2187 	if (cmd->vxlcmd_flags & VXLAN_CMD_FLAG_LEARN)
2188 		sc->vxl_flags |= VXLAN_FLAG_LEARN;
2189 	else
2190 		sc->vxl_flags &= ~VXLAN_FLAG_LEARN;
2191 	VXLAN_WUNLOCK(sc);
2192 
2193 	return (0);
2194 }
2195 
2196 static int
2197 vxlan_ctrl_ftable_entry_add(struct vxlan_softc *sc, void *arg)
2198 {
2199 	union vxlan_sockaddr vxlsa;
2200 	struct ifvxlancmd *cmd;
2201 	struct vxlan_ftable_entry *fe;
2202 	int error;
2203 
2204 	cmd = arg;
2205 	vxlsa = cmd->vxlcmd_sa;
2206 
2207 	if (!VXLAN_SOCKADDR_IS_IPV46(&vxlsa))
2208 		return (EINVAL);
2209 	if (vxlan_sockaddr_in_any(&vxlsa) != 0)
2210 		return (EINVAL);
2211 	if (vxlan_sockaddr_in_multicast(&vxlsa) != 0)
2212 		return (EINVAL);
2213 	/* BMV: We could support both IPv4 and IPv6 later. */
2214 	if (vxlsa.sa.sa_family != sc->vxl_dst_addr.sa.sa_family)
2215 		return (EAFNOSUPPORT);
2216 
2217 	if (VXLAN_SOCKADDR_IS_IPV6(&vxlsa)) {
2218 		error = vxlan_sockaddr_in6_embedscope(&vxlsa);
2219 		if (error)
2220 			return (error);
2221 	}
2222 
2223 	fe = vxlan_ftable_entry_alloc();
2224 	if (fe == NULL)
2225 		return (ENOMEM);
2226 
2227 	if (vxlsa.in4.sin_port == 0)
2228 		vxlsa.in4.sin_port = sc->vxl_dst_addr.in4.sin_port;
2229 
2230 	vxlan_ftable_entry_init(sc, fe, cmd->vxlcmd_mac, &vxlsa.sa,
2231 	    VXLAN_FE_FLAG_STATIC);
2232 
2233 	VXLAN_WLOCK(sc);
2234 	error = vxlan_ftable_entry_insert(sc, fe);
2235 	VXLAN_WUNLOCK(sc);
2236 
2237 	if (error)
2238 		vxlan_ftable_entry_free(fe);
2239 
2240 	return (error);
2241 }
2242 
2243 static int
2244 vxlan_ctrl_ftable_entry_rem(struct vxlan_softc *sc, void *arg)
2245 {
2246 	struct ifvxlancmd *cmd;
2247 	struct vxlan_ftable_entry *fe;
2248 	int error;
2249 
2250 	cmd = arg;
2251 
2252 	VXLAN_WLOCK(sc);
2253 	fe = vxlan_ftable_entry_lookup(sc, cmd->vxlcmd_mac);
2254 	if (fe != NULL) {
2255 		vxlan_ftable_entry_destroy(sc, fe);
2256 		error = 0;
2257 	} else
2258 		error = ENOENT;
2259 	VXLAN_WUNLOCK(sc);
2260 
2261 	return (error);
2262 }
2263 
2264 static int
2265 vxlan_ctrl_flush(struct vxlan_softc *sc, void *arg)
2266 {
2267 	struct ifvxlancmd *cmd;
2268 	int all;
2269 
2270 	cmd = arg;
2271 	all = cmd->vxlcmd_flags & VXLAN_CMD_FLAG_FLUSH_ALL;
2272 
2273 	VXLAN_WLOCK(sc);
2274 	vxlan_ftable_flush(sc, all);
2275 	VXLAN_WUNLOCK(sc);
2276 
2277 	return (0);
2278 }
2279 
2280 static int
2281 vxlan_ioctl_drvspec(struct vxlan_softc *sc, struct ifdrv *ifd, int get)
2282 {
2283 	const struct vxlan_control *vc;
2284 	union {
2285 		struct ifvxlancfg	cfg;
2286 		struct ifvxlancmd	cmd;
2287 	} args;
2288 	int out, error;
2289 
2290 	if (ifd->ifd_cmd >= vxlan_control_table_size)
2291 		return (EINVAL);
2292 
2293 	bzero(&args, sizeof(args));
2294 	vc = &vxlan_control_table[ifd->ifd_cmd];
2295 	out = (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYOUT) != 0;
2296 
2297 	if ((get != 0 && out == 0) || (get == 0 && out != 0))
2298 		return (EINVAL);
2299 
2300 	if (vc->vxlc_flags & VXLAN_CTRL_FLAG_SUSER) {
2301 		error = priv_check(curthread, PRIV_NET_VXLAN);
2302 		if (error)
2303 			return (error);
2304 	}
2305 
2306 	if (ifd->ifd_len != vc->vxlc_argsize ||
2307 	    ifd->ifd_len > sizeof(args))
2308 		return (EINVAL);
2309 
2310 	if (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYIN) {
2311 		error = copyin(ifd->ifd_data, &args, ifd->ifd_len);
2312 		if (error)
2313 			return (error);
2314 	}
2315 
2316 	error = vc->vxlc_func(sc, &args);
2317 	if (error)
2318 		return (error);
2319 
2320 	if (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYOUT) {
2321 		error = copyout(&args, ifd->ifd_data, ifd->ifd_len);
2322 		if (error)
2323 			return (error);
2324 	}
2325 
2326 	return (0);
2327 }
2328 
2329 static int
2330 vxlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2331 {
2332 	struct vxlan_softc *sc;
2333 	struct ifreq *ifr;
2334 	struct ifdrv *ifd;
2335 	int error;
2336 
2337 	sc = ifp->if_softc;
2338 	ifr = (struct ifreq *) data;
2339 	ifd = (struct ifdrv *) data;
2340 
2341 	error = 0;
2342 
2343 	switch (cmd) {
2344 	case SIOCADDMULTI:
2345 	case SIOCDELMULTI:
2346 		break;
2347 
2348 	case SIOCGDRVSPEC:
2349 	case SIOCSDRVSPEC:
2350 		error = vxlan_ioctl_drvspec(sc, ifd, cmd == SIOCGDRVSPEC);
2351 		break;
2352 
2353 	case SIOCSIFFLAGS:
2354 		error = vxlan_ioctl_ifflags(sc);
2355 		break;
2356 
2357 	case SIOCSIFMEDIA:
2358 	case SIOCGIFMEDIA:
2359 		error = ifmedia_ioctl(ifp, ifr, &sc->vxl_media, cmd);
2360 		break;
2361 
2362 	case SIOCSIFMTU:
2363 		if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > VXLAN_MAX_MTU) {
2364 			error = EINVAL;
2365 		} else {
2366 			VXLAN_WLOCK(sc);
2367 			ifp->if_mtu = ifr->ifr_mtu;
2368 			sc->vxl_flags |= VXLAN_FLAG_USER_MTU;
2369 			VXLAN_WUNLOCK(sc);
2370 		}
2371 		break;
2372 
2373 	case SIOCSIFCAP:
2374 		VXLAN_WLOCK(sc);
2375 		error = vxlan_set_reqcap(sc, ifp, ifr->ifr_reqcap);
2376 		if (error == 0)
2377 			vxlan_set_hwcaps(sc);
2378 		VXLAN_WUNLOCK(sc);
2379 		break;
2380 
2381 	default:
2382 		error = ether_ioctl(ifp, cmd, data);
2383 		break;
2384 	}
2385 
2386 	return (error);
2387 }
2388 
2389 #if defined(INET) || defined(INET6)
2390 static uint16_t
2391 vxlan_pick_source_port(struct vxlan_softc *sc, struct mbuf *m)
2392 {
2393 	int range;
2394 	uint32_t hash;
2395 
2396 	range = sc->vxl_max_port - sc->vxl_min_port + 1;
2397 
2398 	if (M_HASHTYPE_ISHASH(m))
2399 		hash = m->m_pkthdr.flowid;
2400 	else
2401 		hash = jenkins_hash(m->m_data, ETHER_HDR_LEN,
2402 		    sc->vxl_port_hash_key);
2403 
2404 	return (sc->vxl_min_port + (hash % range));
2405 }
2406 
2407 static void
2408 vxlan_encap_header(struct vxlan_softc *sc, struct mbuf *m, int ipoff,
2409     uint16_t srcport, uint16_t dstport)
2410 {
2411 	struct vxlanudphdr *hdr;
2412 	struct udphdr *udph;
2413 	struct vxlan_header *vxh;
2414 	int len;
2415 
2416 	len = m->m_pkthdr.len - ipoff;
2417 	MPASS(len >= sizeof(struct vxlanudphdr));
2418 	hdr = mtodo(m, ipoff);
2419 
2420 	udph = &hdr->vxlh_udp;
2421 	udph->uh_sport = srcport;
2422 	udph->uh_dport = dstport;
2423 	udph->uh_ulen = htons(len);
2424 	udph->uh_sum = 0;
2425 
2426 	vxh = &hdr->vxlh_hdr;
2427 	vxh->vxlh_flags = htonl(VXLAN_HDR_FLAGS_VALID_VNI);
2428 	vxh->vxlh_vni = htonl(sc->vxl_vni << VXLAN_HDR_VNI_SHIFT);
2429 }
2430 #endif
2431 
2432 #if defined(INET6) || defined(INET)
2433 /*
2434  * Return the CSUM_INNER_* equivalent of CSUM_* caps.
2435  */
2436 static uint32_t
2437 csum_flags_to_inner_flags(uint32_t csum_flags_in, const uint32_t encap)
2438 {
2439 	uint32_t csum_flags = encap;
2440 	const uint32_t v4 = CSUM_IP | CSUM_IP_UDP | CSUM_IP_TCP;
2441 
2442 	/*
2443 	 * csum_flags can request either v4 or v6 offload but not both.
2444 	 * tcp_output always sets CSUM_TSO (both CSUM_IP_TSO and CSUM_IP6_TSO)
2445 	 * so those bits are no good to detect the IP version.  Other bits are
2446 	 * always set with CSUM_TSO and we use those to figure out the IP
2447 	 * version.
2448 	 */
2449 	if (csum_flags_in & v4) {
2450 		if (csum_flags_in & CSUM_IP)
2451 			csum_flags |= CSUM_INNER_IP;
2452 		if (csum_flags_in & CSUM_IP_UDP)
2453 			csum_flags |= CSUM_INNER_IP_UDP;
2454 		if (csum_flags_in & CSUM_IP_TCP)
2455 			csum_flags |= CSUM_INNER_IP_TCP;
2456 		if (csum_flags_in & CSUM_IP_TSO)
2457 			csum_flags |= CSUM_INNER_IP_TSO;
2458 	} else {
2459 #ifdef INVARIANTS
2460 		const uint32_t v6 = CSUM_IP6_UDP | CSUM_IP6_TCP;
2461 
2462 		MPASS((csum_flags_in & v6) != 0);
2463 #endif
2464 		if (csum_flags_in & CSUM_IP6_UDP)
2465 			csum_flags |= CSUM_INNER_IP6_UDP;
2466 		if (csum_flags_in & CSUM_IP6_TCP)
2467 			csum_flags |= CSUM_INNER_IP6_TCP;
2468 		if (csum_flags_in & CSUM_IP6_TSO)
2469 			csum_flags |= CSUM_INNER_IP6_TSO;
2470 	}
2471 
2472 	return (csum_flags);
2473 }
2474 #endif
2475 
2476 static int
2477 vxlan_encap4(struct vxlan_softc *sc, const union vxlan_sockaddr *fvxlsa,
2478     struct mbuf *m)
2479 {
2480 #ifdef INET
2481 	struct ifnet *ifp;
2482 	struct ip *ip;
2483 	struct in_addr srcaddr, dstaddr;
2484 	uint16_t srcport, dstport;
2485 	int len, mcast, error;
2486 	struct route route, *ro;
2487 	struct sockaddr_in *sin;
2488 	uint32_t csum_flags;
2489 
2490 	NET_EPOCH_ASSERT();
2491 
2492 	ifp = sc->vxl_ifp;
2493 	srcaddr = sc->vxl_src_addr.in4.sin_addr;
2494 	srcport = vxlan_pick_source_port(sc, m);
2495 	dstaddr = fvxlsa->in4.sin_addr;
2496 	dstport = fvxlsa->in4.sin_port;
2497 
2498 	M_PREPEND(m, sizeof(struct ip) + sizeof(struct vxlanudphdr),
2499 	    M_NOWAIT);
2500 	if (m == NULL) {
2501 		if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2502 		return (ENOBUFS);
2503 	}
2504 
2505 	len = m->m_pkthdr.len;
2506 
2507 	ip = mtod(m, struct ip *);
2508 	ip->ip_tos = 0;
2509 	ip->ip_len = htons(len);
2510 	ip->ip_off = 0;
2511 	ip->ip_ttl = sc->vxl_ttl;
2512 	ip->ip_p = IPPROTO_UDP;
2513 	ip->ip_sum = 0;
2514 	ip->ip_src = srcaddr;
2515 	ip->ip_dst = dstaddr;
2516 
2517 	vxlan_encap_header(sc, m, sizeof(struct ip), srcport, dstport);
2518 
2519 	mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0;
2520 	m->m_flags &= ~(M_MCAST | M_BCAST);
2521 
2522 	m->m_pkthdr.csum_flags &= CSUM_FLAGS_TX;
2523 	if (m->m_pkthdr.csum_flags != 0) {
2524 		/*
2525 		 * HW checksum (L3 and/or L4) or TSO has been requested.  Look
2526 		 * up the ifnet for the outbound route and verify that the
2527 		 * outbound ifnet can perform the requested operation on the
2528 		 * inner frame.
2529 		 */
2530 		bzero(&route, sizeof(route));
2531 		ro = &route;
2532 		sin = (struct sockaddr_in *)&ro->ro_dst;
2533 		sin->sin_family = AF_INET;
2534 		sin->sin_len = sizeof(*sin);
2535 		sin->sin_addr = ip->ip_dst;
2536 		ro->ro_nh = fib4_lookup(RT_DEFAULT_FIB, ip->ip_dst, 0, NHR_NONE,
2537 		    0);
2538 		if (ro->ro_nh == NULL) {
2539 			m_freem(m);
2540 			if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2541 			return (EHOSTUNREACH);
2542 		}
2543 
2544 		csum_flags = csum_flags_to_inner_flags(m->m_pkthdr.csum_flags,
2545 		    CSUM_ENCAP_VXLAN);
2546 		if ((csum_flags & ro->ro_nh->nh_ifp->if_hwassist) !=
2547 		    csum_flags) {
2548 			if (ppsratecheck(&sc->err_time, &sc->err_pps, 1)) {
2549 				const struct ifnet *nh_ifp = ro->ro_nh->nh_ifp;
2550 
2551 				if_printf(ifp, "interface %s is missing hwcaps "
2552 				    "0x%08x, csum_flags 0x%08x -> 0x%08x, "
2553 				    "hwassist 0x%08x\n", nh_ifp->if_xname,
2554 				    csum_flags & ~(uint32_t)nh_ifp->if_hwassist,
2555 				    m->m_pkthdr.csum_flags, csum_flags,
2556 				    (uint32_t)nh_ifp->if_hwassist);
2557 			}
2558 			m_freem(m);
2559 			if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2560 			return (ENXIO);
2561 		}
2562 		m->m_pkthdr.csum_flags = csum_flags;
2563 		if (csum_flags &
2564 		    (CSUM_INNER_IP | CSUM_INNER_IP_UDP | CSUM_INNER_IP6_UDP |
2565 		    CSUM_INNER_IP_TCP | CSUM_INNER_IP6_TCP)) {
2566 			counter_u64_add(sc->vxl_stats.txcsum, 1);
2567 			if (csum_flags & CSUM_INNER_TSO)
2568 				counter_u64_add(sc->vxl_stats.tso, 1);
2569 		}
2570 	} else
2571 		ro = NULL;
2572 	error = ip_output(m, NULL, ro, 0, sc->vxl_im4o, NULL);
2573 	if (error == 0) {
2574 		if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2575 		if_inc_counter(ifp, IFCOUNTER_OBYTES, len);
2576 		if (mcast != 0)
2577 			if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
2578 	} else
2579 		if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2580 
2581 	return (error);
2582 #else
2583 	m_freem(m);
2584 	return (ENOTSUP);
2585 #endif
2586 }
2587 
2588 static int
2589 vxlan_encap6(struct vxlan_softc *sc, const union vxlan_sockaddr *fvxlsa,
2590     struct mbuf *m)
2591 {
2592 #ifdef INET6
2593 	struct ifnet *ifp;
2594 	struct ip6_hdr *ip6;
2595 	const struct in6_addr *srcaddr, *dstaddr;
2596 	uint16_t srcport, dstport;
2597 	int len, mcast, error;
2598 	struct route_in6 route, *ro;
2599 	struct sockaddr_in6 *sin6;
2600 	uint32_t csum_flags;
2601 
2602 	NET_EPOCH_ASSERT();
2603 
2604 	ifp = sc->vxl_ifp;
2605 	srcaddr = &sc->vxl_src_addr.in6.sin6_addr;
2606 	srcport = vxlan_pick_source_port(sc, m);
2607 	dstaddr = &fvxlsa->in6.sin6_addr;
2608 	dstport = fvxlsa->in6.sin6_port;
2609 
2610 	M_PREPEND(m, sizeof(struct ip6_hdr) + sizeof(struct vxlanudphdr),
2611 	    M_NOWAIT);
2612 	if (m == NULL) {
2613 		if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2614 		return (ENOBUFS);
2615 	}
2616 
2617 	len = m->m_pkthdr.len;
2618 
2619 	ip6 = mtod(m, struct ip6_hdr *);
2620 	ip6->ip6_flow = 0;		/* BMV: Keep in forwarding entry? */
2621 	ip6->ip6_vfc = IPV6_VERSION;
2622 	ip6->ip6_plen = 0;
2623 	ip6->ip6_nxt = IPPROTO_UDP;
2624 	ip6->ip6_hlim = sc->vxl_ttl;
2625 	ip6->ip6_src = *srcaddr;
2626 	ip6->ip6_dst = *dstaddr;
2627 
2628 	vxlan_encap_header(sc, m, sizeof(struct ip6_hdr), srcport, dstport);
2629 
2630 	mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0;
2631 	m->m_flags &= ~(M_MCAST | M_BCAST);
2632 
2633 	ro = NULL;
2634 	m->m_pkthdr.csum_flags &= CSUM_FLAGS_TX;
2635 	if (m->m_pkthdr.csum_flags != 0) {
2636 		/*
2637 		 * HW checksum (L3 and/or L4) or TSO has been requested.  Look
2638 		 * up the ifnet for the outbound route and verify that the
2639 		 * outbound ifnet can perform the requested operation on the
2640 		 * inner frame.
2641 		 */
2642 		bzero(&route, sizeof(route));
2643 		ro = &route;
2644 		sin6 = (struct sockaddr_in6 *)&ro->ro_dst;
2645 		sin6->sin6_family = AF_INET6;
2646 		sin6->sin6_len = sizeof(*sin6);
2647 		sin6->sin6_addr = ip6->ip6_dst;
2648 		ro->ro_nh = fib6_lookup(RT_DEFAULT_FIB, &ip6->ip6_dst, 0,
2649 		    NHR_NONE, 0);
2650 		if (ro->ro_nh == NULL) {
2651 			m_freem(m);
2652 			if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2653 			return (EHOSTUNREACH);
2654 		}
2655 
2656 		csum_flags = csum_flags_to_inner_flags(m->m_pkthdr.csum_flags,
2657 		    CSUM_ENCAP_VXLAN);
2658 		if ((csum_flags & ro->ro_nh->nh_ifp->if_hwassist) !=
2659 		    csum_flags) {
2660 			if (ppsratecheck(&sc->err_time, &sc->err_pps, 1)) {
2661 				const struct ifnet *nh_ifp = ro->ro_nh->nh_ifp;
2662 
2663 				if_printf(ifp, "interface %s is missing hwcaps "
2664 				    "0x%08x, csum_flags 0x%08x -> 0x%08x, "
2665 				    "hwassist 0x%08x\n", nh_ifp->if_xname,
2666 				    csum_flags & ~(uint32_t)nh_ifp->if_hwassist,
2667 				    m->m_pkthdr.csum_flags, csum_flags,
2668 				    (uint32_t)nh_ifp->if_hwassist);
2669 			}
2670 			m_freem(m);
2671 			if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2672 			return (ENXIO);
2673 		}
2674 		m->m_pkthdr.csum_flags = csum_flags;
2675 		if (csum_flags &
2676 		    (CSUM_INNER_IP | CSUM_INNER_IP_UDP | CSUM_INNER_IP6_UDP |
2677 		    CSUM_INNER_IP_TCP | CSUM_INNER_IP6_TCP)) {
2678 			counter_u64_add(sc->vxl_stats.txcsum, 1);
2679 			if (csum_flags & CSUM_INNER_TSO)
2680 				counter_u64_add(sc->vxl_stats.tso, 1);
2681 		}
2682 	} else if (ntohs(dstport) != V_zero_checksum_port) {
2683 		struct udphdr *hdr = mtodo(m, sizeof(struct ip6_hdr));
2684 
2685 		hdr->uh_sum = in6_cksum_pseudo(ip6,
2686 		    m->m_pkthdr.len - sizeof(struct ip6_hdr), IPPROTO_UDP, 0);
2687 		m->m_pkthdr.csum_flags = CSUM_UDP_IPV6;
2688 		m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
2689 	}
2690 	error = ip6_output(m, NULL, ro, 0, sc->vxl_im6o, NULL, NULL);
2691 	if (error == 0) {
2692 		if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2693 		if_inc_counter(ifp, IFCOUNTER_OBYTES, len);
2694 		if (mcast != 0)
2695 			if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
2696 	} else
2697 		if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2698 
2699 	return (error);
2700 #else
2701 	m_freem(m);
2702 	return (ENOTSUP);
2703 #endif
2704 }
2705 
2706 static int
2707 vxlan_transmit(struct ifnet *ifp, struct mbuf *m)
2708 {
2709 	struct rm_priotracker tracker;
2710 	union vxlan_sockaddr vxlsa;
2711 	struct vxlan_softc *sc;
2712 	struct vxlan_ftable_entry *fe;
2713 	struct ifnet *mcifp;
2714 	struct ether_header *eh;
2715 	int ipv4, error;
2716 
2717 	sc = ifp->if_softc;
2718 	eh = mtod(m, struct ether_header *);
2719 	fe = NULL;
2720 	mcifp = NULL;
2721 
2722 	ETHER_BPF_MTAP(ifp, m);
2723 
2724 	VXLAN_RLOCK(sc, &tracker);
2725 	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
2726 		VXLAN_RUNLOCK(sc, &tracker);
2727 		m_freem(m);
2728 		return (ENETDOWN);
2729 	}
2730 
2731 	if ((m->m_flags & (M_BCAST | M_MCAST)) == 0)
2732 		fe = vxlan_ftable_entry_lookup(sc, eh->ether_dhost);
2733 	if (fe == NULL)
2734 		fe = &sc->vxl_default_fe;
2735 	vxlan_sockaddr_copy(&vxlsa, &fe->vxlfe_raddr.sa);
2736 
2737 	ipv4 = VXLAN_SOCKADDR_IS_IPV4(&vxlsa) != 0;
2738 	if (vxlan_sockaddr_in_multicast(&vxlsa) != 0)
2739 		mcifp = vxlan_multicast_if_ref(sc, ipv4);
2740 
2741 	VXLAN_ACQUIRE(sc);
2742 	VXLAN_RUNLOCK(sc, &tracker);
2743 
2744 	if (ipv4 != 0)
2745 		error = vxlan_encap4(sc, &vxlsa, m);
2746 	else
2747 		error = vxlan_encap6(sc, &vxlsa, m);
2748 
2749 	vxlan_release(sc);
2750 	if (mcifp != NULL)
2751 		if_rele(mcifp);
2752 
2753 	return (error);
2754 }
2755 
2756 static void
2757 vxlan_qflush(struct ifnet *ifp __unused)
2758 {
2759 }
2760 
2761 static void
2762 vxlan_rcv_udp_packet(struct mbuf *m, int offset, struct inpcb *inpcb,
2763     const struct sockaddr *srcsa, void *xvso)
2764 {
2765 	struct vxlan_socket *vso;
2766 	struct vxlan_header *vxh, vxlanhdr;
2767 	uint32_t vni;
2768 	int error __unused;
2769 
2770 	M_ASSERTPKTHDR(m);
2771 	vso = xvso;
2772 	offset += sizeof(struct udphdr);
2773 
2774 	if (m->m_pkthdr.len < offset + sizeof(struct vxlan_header))
2775 		goto out;
2776 
2777 	if (__predict_false(m->m_len < offset + sizeof(struct vxlan_header))) {
2778 		m_copydata(m, offset, sizeof(struct vxlan_header),
2779 		    (caddr_t) &vxlanhdr);
2780 		vxh = &vxlanhdr;
2781 	} else
2782 		vxh = mtodo(m, offset);
2783 
2784 	/*
2785 	 * Drop if there is a reserved bit set in either the flags or VNI
2786 	 * fields of the header. This goes against the specification, but
2787 	 * a bit set may indicate an unsupported new feature. This matches
2788 	 * the behavior of the Linux implementation.
2789 	 */
2790 	if (vxh->vxlh_flags != htonl(VXLAN_HDR_FLAGS_VALID_VNI) ||
2791 	    vxh->vxlh_vni & ~VXLAN_VNI_MASK)
2792 		goto out;
2793 
2794 	vni = ntohl(vxh->vxlh_vni) >> VXLAN_HDR_VNI_SHIFT;
2795 
2796 	/* Adjust to the start of the inner Ethernet frame. */
2797 	m_adj_decap(m, offset + sizeof(struct vxlan_header));
2798 
2799 	error = vxlan_input(vso, vni, &m, srcsa);
2800 	MPASS(error != 0 || m == NULL);
2801 
2802 out:
2803 	if (m != NULL)
2804 		m_freem(m);
2805 }
2806 
2807 static int
2808 vxlan_input(struct vxlan_socket *vso, uint32_t vni, struct mbuf **m0,
2809     const struct sockaddr *sa)
2810 {
2811 	struct vxlan_softc *sc;
2812 	struct ifnet *ifp;
2813 	struct mbuf *m;
2814 	struct ether_header *eh;
2815 	int error;
2816 
2817 	m = *m0;
2818 
2819 	if (m->m_pkthdr.len < ETHER_HDR_LEN)
2820 		return (EINVAL);
2821 
2822 	sc = vxlan_socket_lookup_softc(vso, vni);
2823 	if (sc == NULL)
2824 		return (ENOENT);
2825 
2826 	ifp = sc->vxl_ifp;
2827 	eh = mtod(m, struct ether_header *);
2828 
2829 	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
2830 		error = ENETDOWN;
2831 		goto out;
2832 	} else if (ifp == m->m_pkthdr.rcvif) {
2833 		/* XXX Does not catch more complex loops. */
2834 		error = EDEADLK;
2835 		goto out;
2836 	}
2837 
2838 	if (sc->vxl_flags & VXLAN_FLAG_LEARN)
2839 		vxlan_ftable_learn(sc, sa, eh->ether_shost);
2840 
2841 	m_clrprotoflags(m);
2842 	m->m_pkthdr.rcvif = ifp;
2843 	M_SETFIB(m, ifp->if_fib);
2844 	if (((ifp->if_capenable & IFCAP_RXCSUM &&
2845 	    m->m_pkthdr.csum_flags & CSUM_INNER_L3_CALC) ||
2846 	    (ifp->if_capenable & IFCAP_RXCSUM_IPV6 &&
2847 	    !(m->m_pkthdr.csum_flags & CSUM_INNER_L3_CALC)))) {
2848 		uint32_t csum_flags = 0;
2849 
2850 		if (m->m_pkthdr.csum_flags & CSUM_INNER_L3_CALC)
2851 			csum_flags |= CSUM_L3_CALC;
2852 		if (m->m_pkthdr.csum_flags & CSUM_INNER_L3_VALID)
2853 			csum_flags |= CSUM_L3_VALID;
2854 		if (m->m_pkthdr.csum_flags & CSUM_INNER_L4_CALC)
2855 			csum_flags |= CSUM_L4_CALC;
2856 		if (m->m_pkthdr.csum_flags & CSUM_INNER_L4_VALID)
2857 			csum_flags |= CSUM_L4_VALID;
2858 		m->m_pkthdr.csum_flags = csum_flags;
2859 		counter_u64_add(sc->vxl_stats.rxcsum, 1);
2860 	} else {
2861 		/* clear everything */
2862 		m->m_pkthdr.csum_flags = 0;
2863 		m->m_pkthdr.csum_data = 0;
2864 	}
2865 
2866 	(*ifp->if_input)(ifp, m);
2867 	*m0 = NULL;
2868 	error = 0;
2869 
2870 out:
2871 	vxlan_release(sc);
2872 	return (error);
2873 }
2874 
2875 static int
2876 vxlan_stats_alloc(struct vxlan_softc *sc)
2877 {
2878 	struct vxlan_statistics *stats = &sc->vxl_stats;
2879 
2880 	stats->txcsum = counter_u64_alloc(M_WAITOK);
2881 	if (stats->txcsum == NULL)
2882 		goto failed;
2883 
2884 	stats->tso = counter_u64_alloc(M_WAITOK);
2885 	if (stats->tso == NULL)
2886 		goto failed;
2887 
2888 	stats->rxcsum = counter_u64_alloc(M_WAITOK);
2889 	if (stats->rxcsum == NULL)
2890 		goto failed;
2891 
2892 	return (0);
2893 failed:
2894 	vxlan_stats_free(sc);
2895 	return (ENOMEM);
2896 }
2897 
2898 static void
2899 vxlan_stats_free(struct vxlan_softc *sc)
2900 {
2901 	struct vxlan_statistics *stats = &sc->vxl_stats;
2902 
2903 	if (stats->txcsum != NULL) {
2904 		counter_u64_free(stats->txcsum);
2905 		stats->txcsum = NULL;
2906 	}
2907 	if (stats->tso != NULL) {
2908 		counter_u64_free(stats->tso);
2909 		stats->tso = NULL;
2910 	}
2911 	if (stats->rxcsum != NULL) {
2912 		counter_u64_free(stats->rxcsum);
2913 		stats->rxcsum = NULL;
2914 	}
2915 }
2916 
2917 static void
2918 vxlan_set_default_config(struct vxlan_softc *sc)
2919 {
2920 
2921 	sc->vxl_flags |= VXLAN_FLAG_LEARN;
2922 
2923 	sc->vxl_vni = VXLAN_VNI_MAX;
2924 	sc->vxl_ttl = IPDEFTTL;
2925 
2926 	if (!vxlan_tunable_int(sc, "legacy_port", vxlan_legacy_port)) {
2927 		sc->vxl_src_addr.in4.sin_port = htons(VXLAN_PORT);
2928 		sc->vxl_dst_addr.in4.sin_port = htons(VXLAN_PORT);
2929 	} else {
2930 		sc->vxl_src_addr.in4.sin_port = htons(VXLAN_LEGACY_PORT);
2931 		sc->vxl_dst_addr.in4.sin_port = htons(VXLAN_LEGACY_PORT);
2932 	}
2933 
2934 	sc->vxl_min_port = V_ipport_firstauto;
2935 	sc->vxl_max_port = V_ipport_lastauto;
2936 
2937 	sc->vxl_ftable_max = VXLAN_FTABLE_MAX;
2938 	sc->vxl_ftable_timeout = VXLAN_FTABLE_TIMEOUT;
2939 }
2940 
2941 static int
2942 vxlan_set_user_config(struct vxlan_softc *sc, struct ifvxlanparam *vxlp)
2943 {
2944 
2945 #ifndef INET
2946 	if (vxlp->vxlp_with & (VXLAN_PARAM_WITH_LOCAL_ADDR4 |
2947 	    VXLAN_PARAM_WITH_REMOTE_ADDR4))
2948 		return (EAFNOSUPPORT);
2949 #endif
2950 
2951 #ifndef INET6
2952 	if (vxlp->vxlp_with & (VXLAN_PARAM_WITH_LOCAL_ADDR6 |
2953 	    VXLAN_PARAM_WITH_REMOTE_ADDR6))
2954 		return (EAFNOSUPPORT);
2955 #else
2956 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR6) {
2957 		int error = vxlan_sockaddr_in6_embedscope(&vxlp->vxlp_local_sa);
2958 		if (error)
2959 			return (error);
2960 	}
2961 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR6) {
2962 		int error = vxlan_sockaddr_in6_embedscope(
2963 		   &vxlp->vxlp_remote_sa);
2964 		if (error)
2965 			return (error);
2966 	}
2967 #endif
2968 
2969 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_VNI) {
2970 		if (vxlan_check_vni(vxlp->vxlp_vni) == 0)
2971 			sc->vxl_vni = vxlp->vxlp_vni;
2972 	}
2973 
2974 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR4) {
2975 		sc->vxl_src_addr.in4.sin_len = sizeof(struct sockaddr_in);
2976 		sc->vxl_src_addr.in4.sin_family = AF_INET;
2977 		sc->vxl_src_addr.in4.sin_addr =
2978 		    vxlp->vxlp_local_sa.in4.sin_addr;
2979 	} else if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR6) {
2980 		sc->vxl_src_addr.in6.sin6_len = sizeof(struct sockaddr_in6);
2981 		sc->vxl_src_addr.in6.sin6_family = AF_INET6;
2982 		sc->vxl_src_addr.in6.sin6_addr =
2983 		    vxlp->vxlp_local_sa.in6.sin6_addr;
2984 	}
2985 
2986 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR4) {
2987 		sc->vxl_dst_addr.in4.sin_len = sizeof(struct sockaddr_in);
2988 		sc->vxl_dst_addr.in4.sin_family = AF_INET;
2989 		sc->vxl_dst_addr.in4.sin_addr =
2990 		    vxlp->vxlp_remote_sa.in4.sin_addr;
2991 	} else if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR6) {
2992 		sc->vxl_dst_addr.in6.sin6_len = sizeof(struct sockaddr_in6);
2993 		sc->vxl_dst_addr.in6.sin6_family = AF_INET6;
2994 		sc->vxl_dst_addr.in6.sin6_addr =
2995 		    vxlp->vxlp_remote_sa.in6.sin6_addr;
2996 	}
2997 
2998 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_PORT)
2999 		sc->vxl_src_addr.in4.sin_port = htons(vxlp->vxlp_local_port);
3000 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_PORT)
3001 		sc->vxl_dst_addr.in4.sin_port = htons(vxlp->vxlp_remote_port);
3002 
3003 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_PORT_RANGE) {
3004 		if (vxlp->vxlp_min_port <= vxlp->vxlp_max_port) {
3005 			sc->vxl_min_port = vxlp->vxlp_min_port;
3006 			sc->vxl_max_port = vxlp->vxlp_max_port;
3007 		}
3008 	}
3009 
3010 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_MULTICAST_IF)
3011 		strlcpy(sc->vxl_mc_ifname, vxlp->vxlp_mc_ifname, IFNAMSIZ);
3012 
3013 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_FTABLE_TIMEOUT) {
3014 		if (vxlan_check_ftable_timeout(vxlp->vxlp_ftable_timeout) == 0)
3015 			sc->vxl_ftable_timeout = vxlp->vxlp_ftable_timeout;
3016 	}
3017 
3018 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_FTABLE_MAX) {
3019 		if (vxlan_check_ftable_max(vxlp->vxlp_ftable_max) == 0)
3020 			sc->vxl_ftable_max = vxlp->vxlp_ftable_max;
3021 	}
3022 
3023 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_TTL) {
3024 		if (vxlan_check_ttl(vxlp->vxlp_ttl) == 0)
3025 			sc->vxl_ttl = vxlp->vxlp_ttl;
3026 	}
3027 
3028 	if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LEARN) {
3029 		if (vxlp->vxlp_learn == 0)
3030 			sc->vxl_flags &= ~VXLAN_FLAG_LEARN;
3031 	}
3032 
3033 	return (0);
3034 }
3035 
3036 static int
3037 vxlan_set_reqcap(struct vxlan_softc *sc, struct ifnet *ifp, int reqcap)
3038 {
3039 	int mask = reqcap ^ ifp->if_capenable;
3040 
3041 	/* Disable TSO if tx checksums are disabled. */
3042 	if (mask & IFCAP_TXCSUM && !(reqcap & IFCAP_TXCSUM) &&
3043 	    reqcap & IFCAP_TSO4) {
3044 		reqcap &= ~IFCAP_TSO4;
3045 		if_printf(ifp, "tso4 disabled due to -txcsum.\n");
3046 	}
3047 	if (mask & IFCAP_TXCSUM_IPV6 && !(reqcap & IFCAP_TXCSUM_IPV6) &&
3048 	    reqcap & IFCAP_TSO6) {
3049 		reqcap &= ~IFCAP_TSO6;
3050 		if_printf(ifp, "tso6 disabled due to -txcsum6.\n");
3051 	}
3052 
3053 	/* Do not enable TSO if tx checksums are disabled. */
3054 	if (mask & IFCAP_TSO4 && reqcap & IFCAP_TSO4 &&
3055 	    !(reqcap & IFCAP_TXCSUM)) {
3056 		if_printf(ifp, "enable txcsum first.\n");
3057 		return (EAGAIN);
3058 	}
3059 	if (mask & IFCAP_TSO6 && reqcap & IFCAP_TSO6 &&
3060 	    !(reqcap & IFCAP_TXCSUM_IPV6)) {
3061 		if_printf(ifp, "enable txcsum6 first.\n");
3062 		return (EAGAIN);
3063 	}
3064 
3065 	sc->vxl_reqcap = reqcap;
3066 	return (0);
3067 }
3068 
3069 /*
3070  * A VXLAN interface inherits the capabilities of the vxlandev or the interface
3071  * hosting the vxlanlocal address.
3072  */
3073 static void
3074 vxlan_set_hwcaps(struct vxlan_softc *sc)
3075 {
3076 	struct epoch_tracker et;
3077 	struct ifnet *p;
3078 	struct ifaddr *ifa;
3079 	u_long hwa;
3080 	int cap, ena;
3081 	bool rel;
3082 	struct ifnet *ifp = sc->vxl_ifp;
3083 
3084 	/* reset caps */
3085 	ifp->if_capabilities &= VXLAN_BASIC_IFCAPS;
3086 	ifp->if_capenable &= VXLAN_BASIC_IFCAPS;
3087 	ifp->if_hwassist = 0;
3088 
3089 	NET_EPOCH_ENTER(et);
3090 	CURVNET_SET(ifp->if_vnet);
3091 
3092 	rel = false;
3093 	p = NULL;
3094 	if (sc->vxl_mc_ifname[0] != '\0') {
3095 		rel = true;
3096 		p = ifunit_ref(sc->vxl_mc_ifname);
3097 	} else if (vxlan_sockaddr_in_any(&sc->vxl_src_addr) == 0) {
3098 		if (sc->vxl_src_addr.sa.sa_family == AF_INET) {
3099 			struct sockaddr_in in4 = sc->vxl_src_addr.in4;
3100 
3101 			in4.sin_port = 0;
3102 			ifa = ifa_ifwithaddr((struct sockaddr *)&in4);
3103 			if (ifa != NULL)
3104 				p = ifa->ifa_ifp;
3105 		} else if (sc->vxl_src_addr.sa.sa_family == AF_INET6) {
3106 			struct sockaddr_in6 in6 = sc->vxl_src_addr.in6;
3107 
3108 			in6.sin6_port = 0;
3109 			ifa = ifa_ifwithaddr((struct sockaddr *)&in6);
3110 			if (ifa != NULL)
3111 				p = ifa->ifa_ifp;
3112 		}
3113 	}
3114 	if (p == NULL)
3115 		goto done;
3116 
3117 	cap = ena = hwa = 0;
3118 
3119 	/* checksum offload */
3120 	if (p->if_capabilities & IFCAP_VXLAN_HWCSUM)
3121 		cap |= p->if_capabilities & (IFCAP_HWCSUM | IFCAP_HWCSUM_IPV6);
3122 	if (p->if_capenable & IFCAP_VXLAN_HWCSUM) {
3123 		ena |= sc->vxl_reqcap & p->if_capenable &
3124 		    (IFCAP_HWCSUM | IFCAP_HWCSUM_IPV6);
3125 		if (ena & IFCAP_TXCSUM) {
3126 			if (p->if_hwassist & CSUM_INNER_IP)
3127 				hwa |= CSUM_IP;
3128 			if (p->if_hwassist & CSUM_INNER_IP_UDP)
3129 				hwa |= CSUM_IP_UDP;
3130 			if (p->if_hwassist & CSUM_INNER_IP_TCP)
3131 				hwa |= CSUM_IP_TCP;
3132 		}
3133 		if (ena & IFCAP_TXCSUM_IPV6) {
3134 			if (p->if_hwassist & CSUM_INNER_IP6_UDP)
3135 				hwa |= CSUM_IP6_UDP;
3136 			if (p->if_hwassist & CSUM_INNER_IP6_TCP)
3137 				hwa |= CSUM_IP6_TCP;
3138 		}
3139 	}
3140 
3141 	/* hardware TSO */
3142 	if (p->if_capabilities & IFCAP_VXLAN_HWTSO) {
3143 		cap |= p->if_capabilities & IFCAP_TSO;
3144 		if (p->if_hw_tsomax > IP_MAXPACKET - ifp->if_hdrlen)
3145 			ifp->if_hw_tsomax = IP_MAXPACKET - ifp->if_hdrlen;
3146 		else
3147 			ifp->if_hw_tsomax = p->if_hw_tsomax;
3148 		/* XXX: tsomaxsegcount decrement is cxgbe specific  */
3149 		ifp->if_hw_tsomaxsegcount = p->if_hw_tsomaxsegcount - 1;
3150 		ifp->if_hw_tsomaxsegsize = p->if_hw_tsomaxsegsize;
3151 	}
3152 	if (p->if_capenable & IFCAP_VXLAN_HWTSO) {
3153 		ena |= sc->vxl_reqcap & p->if_capenable & IFCAP_TSO;
3154 		if (ena & IFCAP_TSO) {
3155 			if (p->if_hwassist & CSUM_INNER_IP_TSO)
3156 				hwa |= CSUM_IP_TSO;
3157 			if (p->if_hwassist & CSUM_INNER_IP6_TSO)
3158 				hwa |= CSUM_IP6_TSO;
3159 		}
3160 	}
3161 
3162 	ifp->if_capabilities |= cap;
3163 	ifp->if_capenable |= ena;
3164 	ifp->if_hwassist |= hwa;
3165 	if (rel)
3166 		if_rele(p);
3167 done:
3168 	CURVNET_RESTORE();
3169 	NET_EPOCH_EXIT(et);
3170 }
3171 
3172 static int
3173 vxlan_clone_create(struct if_clone *ifc, int unit, caddr_t params)
3174 {
3175 	struct vxlan_softc *sc;
3176 	struct ifnet *ifp;
3177 	struct ifvxlanparam vxlp;
3178 	int error;
3179 
3180 	sc = malloc(sizeof(struct vxlan_softc), M_VXLAN, M_WAITOK | M_ZERO);
3181 	sc->vxl_unit = unit;
3182 	vxlan_set_default_config(sc);
3183 	error = vxlan_stats_alloc(sc);
3184 	if (error != 0)
3185 		goto fail;
3186 
3187 	if (params != 0) {
3188 		error = copyin(params, &vxlp, sizeof(vxlp));
3189 		if (error)
3190 			goto fail;
3191 
3192 		error = vxlan_set_user_config(sc, &vxlp);
3193 		if (error)
3194 			goto fail;
3195 	}
3196 
3197 	ifp = if_alloc(IFT_ETHER);
3198 	if (ifp == NULL) {
3199 		error = ENOSPC;
3200 		goto fail;
3201 	}
3202 
3203 	sc->vxl_ifp = ifp;
3204 	rm_init(&sc->vxl_lock, "vxlanrm");
3205 	callout_init_rw(&sc->vxl_callout, &sc->vxl_lock, 0);
3206 	sc->vxl_port_hash_key = arc4random();
3207 	vxlan_ftable_init(sc);
3208 
3209 	vxlan_sysctl_setup(sc);
3210 
3211 	ifp->if_softc = sc;
3212 	if_initname(ifp, vxlan_name, unit);
3213 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
3214 	ifp->if_init = vxlan_init;
3215 	ifp->if_ioctl = vxlan_ioctl;
3216 	ifp->if_transmit = vxlan_transmit;
3217 	ifp->if_qflush = vxlan_qflush;
3218 	ifp->if_capabilities = VXLAN_BASIC_IFCAPS;
3219 	ifp->if_capenable = VXLAN_BASIC_IFCAPS;
3220 	sc->vxl_reqcap = -1;
3221 	vxlan_set_hwcaps(sc);
3222 
3223 	ifmedia_init(&sc->vxl_media, 0, vxlan_media_change, vxlan_media_status);
3224 	ifmedia_add(&sc->vxl_media, IFM_ETHER | IFM_AUTO, 0, NULL);
3225 	ifmedia_set(&sc->vxl_media, IFM_ETHER | IFM_AUTO);
3226 
3227 	ether_gen_addr(ifp, &sc->vxl_hwaddr);
3228 	ether_ifattach(ifp, sc->vxl_hwaddr.octet);
3229 
3230 	ifp->if_baudrate = 0;
3231 
3232 	VXLAN_WLOCK(sc);
3233 	vxlan_setup_interface_hdrlen(sc);
3234 	VXLAN_WUNLOCK(sc);
3235 
3236 	return (0);
3237 
3238 fail:
3239 	free(sc, M_VXLAN);
3240 	return (error);
3241 }
3242 
3243 static void
3244 vxlan_clone_destroy(struct ifnet *ifp)
3245 {
3246 	struct vxlan_softc *sc;
3247 
3248 	sc = ifp->if_softc;
3249 
3250 	vxlan_teardown(sc);
3251 
3252 	vxlan_ftable_flush(sc, 1);
3253 
3254 	ether_ifdetach(ifp);
3255 	if_free(ifp);
3256 	ifmedia_removeall(&sc->vxl_media);
3257 
3258 	vxlan_ftable_fini(sc);
3259 
3260 	vxlan_sysctl_destroy(sc);
3261 	rm_destroy(&sc->vxl_lock);
3262 	vxlan_stats_free(sc);
3263 	free(sc, M_VXLAN);
3264 }
3265 
3266 /* BMV: Taken from if_bridge. */
3267 static uint32_t
3268 vxlan_mac_hash(struct vxlan_softc *sc, const uint8_t *addr)
3269 {
3270 	uint32_t a = 0x9e3779b9, b = 0x9e3779b9, c = sc->vxl_ftable_hash_key;
3271 
3272 	b += addr[5] << 8;
3273 	b += addr[4];
3274 	a += addr[3] << 24;
3275 	a += addr[2] << 16;
3276 	a += addr[1] << 8;
3277 	a += addr[0];
3278 
3279 /*
3280  * The following hash function is adapted from "Hash Functions" by Bob Jenkins
3281  * ("Algorithm Alley", Dr. Dobbs Journal, September 1997).
3282  */
3283 #define	mix(a, b, c)							\
3284 do {									\
3285 	a -= b; a -= c; a ^= (c >> 13);					\
3286 	b -= c; b -= a; b ^= (a << 8);					\
3287 	c -= a; c -= b; c ^= (b >> 13);					\
3288 	a -= b; a -= c; a ^= (c >> 12);					\
3289 	b -= c; b -= a; b ^= (a << 16);					\
3290 	c -= a; c -= b; c ^= (b >> 5);					\
3291 	a -= b; a -= c; a ^= (c >> 3);					\
3292 	b -= c; b -= a; b ^= (a << 10);					\
3293 	c -= a; c -= b; c ^= (b >> 15);					\
3294 } while (0)
3295 
3296 	mix(a, b, c);
3297 
3298 #undef mix
3299 
3300 	return (c);
3301 }
3302 
3303 static int
3304 vxlan_media_change(struct ifnet *ifp)
3305 {
3306 
3307 	/* Ignore. */
3308 	return (0);
3309 }
3310 
3311 static void
3312 vxlan_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
3313 {
3314 
3315 	ifmr->ifm_status = IFM_ACTIVE | IFM_AVALID;
3316 	ifmr->ifm_active = IFM_ETHER | IFM_FDX;
3317 }
3318 
3319 static int
3320 vxlan_sockaddr_cmp(const union vxlan_sockaddr *vxladdr,
3321     const struct sockaddr *sa)
3322 {
3323 
3324 	return (bcmp(&vxladdr->sa, sa, vxladdr->sa.sa_len));
3325 }
3326 
3327 static void
3328 vxlan_sockaddr_copy(union vxlan_sockaddr *vxladdr,
3329     const struct sockaddr *sa)
3330 {
3331 
3332 	MPASS(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
3333 	bzero(vxladdr, sizeof(*vxladdr));
3334 
3335 	if (sa->sa_family == AF_INET) {
3336 		vxladdr->in4 = *satoconstsin(sa);
3337 		vxladdr->in4.sin_len = sizeof(struct sockaddr_in);
3338 	} else if (sa->sa_family == AF_INET6) {
3339 		vxladdr->in6 = *satoconstsin6(sa);
3340 		vxladdr->in6.sin6_len = sizeof(struct sockaddr_in6);
3341 	}
3342 }
3343 
3344 static int
3345 vxlan_sockaddr_in_equal(const union vxlan_sockaddr *vxladdr,
3346     const struct sockaddr *sa)
3347 {
3348 	int equal;
3349 
3350 	if (sa->sa_family == AF_INET) {
3351 		const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
3352 		equal = in4->s_addr == vxladdr->in4.sin_addr.s_addr;
3353 	} else if (sa->sa_family == AF_INET6) {
3354 		const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
3355 		equal = IN6_ARE_ADDR_EQUAL(in6, &vxladdr->in6.sin6_addr);
3356 	} else
3357 		equal = 0;
3358 
3359 	return (equal);
3360 }
3361 
3362 static void
3363 vxlan_sockaddr_in_copy(union vxlan_sockaddr *vxladdr,
3364     const struct sockaddr *sa)
3365 {
3366 
3367 	MPASS(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
3368 
3369 	if (sa->sa_family == AF_INET) {
3370 		const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
3371 		vxladdr->in4.sin_family = AF_INET;
3372 		vxladdr->in4.sin_len = sizeof(struct sockaddr_in);
3373 		vxladdr->in4.sin_addr = *in4;
3374 	} else if (sa->sa_family == AF_INET6) {
3375 		const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
3376 		vxladdr->in6.sin6_family = AF_INET6;
3377 		vxladdr->in6.sin6_len = sizeof(struct sockaddr_in6);
3378 		vxladdr->in6.sin6_addr = *in6;
3379 	}
3380 }
3381 
3382 static int
3383 vxlan_sockaddr_supported(const union vxlan_sockaddr *vxladdr, int unspec)
3384 {
3385 	const struct sockaddr *sa;
3386 	int supported;
3387 
3388 	sa = &vxladdr->sa;
3389 	supported = 0;
3390 
3391 	if (sa->sa_family == AF_UNSPEC && unspec != 0) {
3392 		supported = 1;
3393 	} else if (sa->sa_family == AF_INET) {
3394 #ifdef INET
3395 		supported = 1;
3396 #endif
3397 	} else if (sa->sa_family == AF_INET6) {
3398 #ifdef INET6
3399 		supported = 1;
3400 #endif
3401 	}
3402 
3403 	return (supported);
3404 }
3405 
3406 static int
3407 vxlan_sockaddr_in_any(const union vxlan_sockaddr *vxladdr)
3408 {
3409 	const struct sockaddr *sa;
3410 	int any;
3411 
3412 	sa = &vxladdr->sa;
3413 
3414 	if (sa->sa_family == AF_INET) {
3415 		const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
3416 		any = in4->s_addr == INADDR_ANY;
3417 	} else if (sa->sa_family == AF_INET6) {
3418 		const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
3419 		any = IN6_IS_ADDR_UNSPECIFIED(in6);
3420 	} else
3421 		any = -1;
3422 
3423 	return (any);
3424 }
3425 
3426 static int
3427 vxlan_sockaddr_in_multicast(const union vxlan_sockaddr *vxladdr)
3428 {
3429 	const struct sockaddr *sa;
3430 	int mc;
3431 
3432 	sa = &vxladdr->sa;
3433 
3434 	if (sa->sa_family == AF_INET) {
3435 		const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
3436 		mc = IN_MULTICAST(ntohl(in4->s_addr));
3437 	} else if (sa->sa_family == AF_INET6) {
3438 		const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
3439 		mc = IN6_IS_ADDR_MULTICAST(in6);
3440 	} else
3441 		mc = -1;
3442 
3443 	return (mc);
3444 }
3445 
3446 static int
3447 vxlan_sockaddr_in6_embedscope(union vxlan_sockaddr *vxladdr)
3448 {
3449 	int error;
3450 
3451 	MPASS(VXLAN_SOCKADDR_IS_IPV6(vxladdr));
3452 #ifdef INET6
3453 	error = sa6_embedscope(&vxladdr->in6, V_ip6_use_defzone);
3454 #else
3455 	error = EAFNOSUPPORT;
3456 #endif
3457 
3458 	return (error);
3459 }
3460 
3461 static int
3462 vxlan_can_change_config(struct vxlan_softc *sc)
3463 {
3464 	struct ifnet *ifp;
3465 
3466 	ifp = sc->vxl_ifp;
3467 	VXLAN_LOCK_ASSERT(sc);
3468 
3469 	if (ifp->if_drv_flags & IFF_DRV_RUNNING)
3470 		return (0);
3471 	if (sc->vxl_flags & (VXLAN_FLAG_INIT | VXLAN_FLAG_TEARDOWN))
3472 		return (0);
3473 
3474 	return (1);
3475 }
3476 
3477 static int
3478 vxlan_check_vni(uint32_t vni)
3479 {
3480 
3481 	return (vni >= VXLAN_VNI_MAX);
3482 }
3483 
3484 static int
3485 vxlan_check_ttl(int ttl)
3486 {
3487 
3488 	return (ttl > MAXTTL);
3489 }
3490 
3491 static int
3492 vxlan_check_ftable_timeout(uint32_t timeout)
3493 {
3494 
3495 	return (timeout > VXLAN_FTABLE_MAX_TIMEOUT);
3496 }
3497 
3498 static int
3499 vxlan_check_ftable_max(uint32_t max)
3500 {
3501 
3502 	return (max > VXLAN_FTABLE_MAX);
3503 }
3504 
3505 static void
3506 vxlan_sysctl_setup(struct vxlan_softc *sc)
3507 {
3508 	struct sysctl_ctx_list *ctx;
3509 	struct sysctl_oid *node;
3510 	struct vxlan_statistics *stats;
3511 	char namebuf[8];
3512 
3513 	ctx = &sc->vxl_sysctl_ctx;
3514 	stats = &sc->vxl_stats;
3515 	snprintf(namebuf, sizeof(namebuf), "%d", sc->vxl_unit);
3516 
3517 	sysctl_ctx_init(ctx);
3518 	sc->vxl_sysctl_node = SYSCTL_ADD_NODE(ctx,
3519 	    SYSCTL_STATIC_CHILDREN(_net_link_vxlan), OID_AUTO, namebuf,
3520 	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
3521 
3522 	node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sc->vxl_sysctl_node),
3523 	    OID_AUTO, "ftable", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
3524 	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "count",
3525 	    CTLFLAG_RD, &sc->vxl_ftable_cnt, 0,
3526 	    "Number of entries in fowarding table");
3527 	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "max",
3528 	     CTLFLAG_RD, &sc->vxl_ftable_max, 0,
3529 	    "Maximum number of entries allowed in fowarding table");
3530 	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "timeout",
3531 	    CTLFLAG_RD, &sc->vxl_ftable_timeout, 0,
3532 	    "Number of seconds between prunes of the forwarding table");
3533 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "dump",
3534 	    CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_SKIP,
3535 	    sc, 0, vxlan_ftable_sysctl_dump, "A",
3536 	    "Dump the forwarding table entries");
3537 
3538 	node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sc->vxl_sysctl_node),
3539 	    OID_AUTO, "stats", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
3540 	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
3541 	    "ftable_nospace", CTLFLAG_RD, &stats->ftable_nospace, 0,
3542 	    "Fowarding table reached maximum entries");
3543 	SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
3544 	    "ftable_lock_upgrade_failed", CTLFLAG_RD,
3545 	    &stats->ftable_lock_upgrade_failed, 0,
3546 	    "Forwarding table update required lock upgrade");
3547 
3548 	SYSCTL_ADD_COUNTER_U64(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "txcsum",
3549 	    CTLFLAG_RD, &stats->txcsum,
3550 	    "# of times hardware assisted with tx checksum");
3551 	SYSCTL_ADD_COUNTER_U64(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "tso",
3552 	    CTLFLAG_RD, &stats->tso, "# of times hardware assisted with TSO");
3553 	SYSCTL_ADD_COUNTER_U64(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "rxcsum",
3554 	    CTLFLAG_RD, &stats->rxcsum,
3555 	    "# of times hardware assisted with rx checksum");
3556 }
3557 
3558 static void
3559 vxlan_sysctl_destroy(struct vxlan_softc *sc)
3560 {
3561 
3562 	sysctl_ctx_free(&sc->vxl_sysctl_ctx);
3563 	sc->vxl_sysctl_node = NULL;
3564 }
3565 
3566 static int
3567 vxlan_tunable_int(struct vxlan_softc *sc, const char *knob, int def)
3568 {
3569 	char path[64];
3570 
3571 	snprintf(path, sizeof(path), "net.link.vxlan.%d.%s",
3572 	    sc->vxl_unit, knob);
3573 	TUNABLE_INT_FETCH(path, &def);
3574 
3575 	return (def);
3576 }
3577 
3578 static void
3579 vxlan_ifdetach_event(void *arg __unused, struct ifnet *ifp)
3580 {
3581 	struct vxlan_softc_head list;
3582 	struct vxlan_socket *vso;
3583 	struct vxlan_softc *sc, *tsc;
3584 
3585 	LIST_INIT(&list);
3586 
3587 	if (ifp->if_flags & IFF_RENAMING)
3588 		return;
3589 	if ((ifp->if_flags & IFF_MULTICAST) == 0)
3590 		return;
3591 
3592 	VXLAN_LIST_LOCK();
3593 	LIST_FOREACH(vso, &vxlan_socket_list, vxlso_entry)
3594 		vxlan_socket_ifdetach(vso, ifp, &list);
3595 	VXLAN_LIST_UNLOCK();
3596 
3597 	LIST_FOREACH_SAFE(sc, &list, vxl_ifdetach_list, tsc) {
3598 		LIST_REMOVE(sc, vxl_ifdetach_list);
3599 
3600 		sx_xlock(&vxlan_sx);
3601 		VXLAN_WLOCK(sc);
3602 		if (sc->vxl_flags & VXLAN_FLAG_INIT)
3603 			vxlan_init_wait(sc);
3604 		vxlan_teardown_locked(sc);
3605 		sx_xunlock(&vxlan_sx);
3606 	}
3607 }
3608 
3609 static void
3610 vxlan_load(void)
3611 {
3612 
3613 	mtx_init(&vxlan_list_mtx, "vxlan list", NULL, MTX_DEF);
3614 	LIST_INIT(&vxlan_socket_list);
3615 	vxlan_ifdetach_event_tag = EVENTHANDLER_REGISTER(ifnet_departure_event,
3616 	    vxlan_ifdetach_event, NULL, EVENTHANDLER_PRI_ANY);
3617 	vxlan_cloner = if_clone_simple(vxlan_name, vxlan_clone_create,
3618 	    vxlan_clone_destroy, 0);
3619 }
3620 
3621 static void
3622 vxlan_unload(void)
3623 {
3624 
3625 	EVENTHANDLER_DEREGISTER(ifnet_departure_event,
3626 	    vxlan_ifdetach_event_tag);
3627 	if_clone_detach(vxlan_cloner);
3628 	mtx_destroy(&vxlan_list_mtx);
3629 	MPASS(LIST_EMPTY(&vxlan_socket_list));
3630 }
3631 
3632 static int
3633 vxlan_modevent(module_t mod, int type, void *unused)
3634 {
3635 	int error;
3636 
3637 	error = 0;
3638 
3639 	switch (type) {
3640 	case MOD_LOAD:
3641 		vxlan_load();
3642 		break;
3643 	case MOD_UNLOAD:
3644 		vxlan_unload();
3645 		break;
3646 	default:
3647 		error = ENOTSUP;
3648 		break;
3649 	}
3650 
3651 	return (error);
3652 }
3653 
3654 static moduledata_t vxlan_mod = {
3655 	"if_vxlan",
3656 	vxlan_modevent,
3657 	0
3658 };
3659 
3660 DECLARE_MODULE(if_vxlan, vxlan_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
3661 MODULE_VERSION(if_vxlan, 1);
3662