2 * Copyright (c) 2014, Bryan Venteicher <bryanv@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 #include "opt_inet6.h"
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
33 #include <sys/param.h>
34 #include <sys/eventhandler.h>
35 #include <sys/kernel.h>
38 #include <sys/malloc.h>
40 #include <sys/module.h>
41 #include <sys/refcount.h>
42 #include <sys/rmlock.h>
45 #include <sys/queue.h>
47 #include <sys/socket.h>
48 #include <sys/socketvar.h>
49 #include <sys/sockio.h>
50 #include <sys/sysctl.h>
51 #include <sys/systm.h>
54 #include <net/ethernet.h>
56 #include <net/if_var.h>
57 #include <net/if_clone.h>
58 #include <net/if_dl.h>
59 #include <net/if_media.h>
60 #include <net/if_types.h>
61 #include <net/if_vxlan.h>
62 #include <net/netisr.h>
64 #include <netinet/in.h>
65 #include <netinet/in_systm.h>
66 #include <netinet/in_var.h>
67 #include <netinet/in_pcb.h>
68 #include <netinet/ip.h>
69 #include <netinet/ip6.h>
70 #include <netinet/ip_var.h>
71 #include <netinet/udp.h>
72 #include <netinet/udp_var.h>
74 #include <netinet6/ip6_var.h>
75 #include <netinet6/scope6_var.h>
78 LIST_HEAD(vxlan_softc_head, vxlan_softc);
80 struct vxlan_socket_mc_info {
81 union vxlan_sockaddr vxlsomc_saddr;
82 union vxlan_sockaddr vxlsomc_gaddr;
87 #define VXLAN_SO_MC_MAX_GROUPS 32
89 #define VXLAN_SO_VNI_HASH_SHIFT 6
90 #define VXLAN_SO_VNI_HASH_SIZE (1 << VXLAN_SO_VNI_HASH_SHIFT)
91 #define VXLAN_SO_VNI_HASH(_vni) ((_vni) % VXLAN_SO_VNI_HASH_SIZE)
94 struct socket *vxlso_sock;
95 struct rmlock vxlso_lock;
97 union vxlan_sockaddr vxlso_laddr;
98 LIST_ENTRY(vxlan_socket) vxlso_entry;
99 struct vxlan_softc_head vxlso_vni_hash[VXLAN_SO_VNI_HASH_SIZE];
100 struct vxlan_socket_mc_info vxlso_mc[VXLAN_SO_MC_MAX_GROUPS];
103 #define VXLAN_SO_RLOCK(_vso, _p) rm_rlock(&(_vso)->vxlso_lock, (_p))
104 #define VXLAN_SO_RUNLOCK(_vso, _p) rm_runlock(&(_vso)->vxlso_lock, (_p))
105 #define VXLAN_SO_WLOCK(_vso) rm_wlock(&(_vso)->vxlso_lock)
106 #define VXLAN_SO_WUNLOCK(_vso) rm_wunlock(&(_vso)->vxlso_lock)
107 #define VXLAN_SO_LOCK_ASSERT(_vso) \
108 rm_assert(&(_vso)->vxlso_lock, RA_LOCKED)
109 #define VXLAN_SO_LOCK_WASSERT(_vso) \
110 rm_assert(&(_vso)->vxlso_lock, RA_WLOCKED)
112 #define VXLAN_SO_ACQUIRE(_vso) refcount_acquire(&(_vso)->vxlso_refcnt)
113 #define VXLAN_SO_RELEASE(_vso) refcount_release(&(_vso)->vxlso_refcnt)
115 struct vxlan_ftable_entry {
116 LIST_ENTRY(vxlan_ftable_entry) vxlfe_hash;
117 uint16_t vxlfe_flags;
118 uint8_t vxlfe_mac[ETHER_ADDR_LEN];
119 union vxlan_sockaddr vxlfe_raddr;
123 #define VXLAN_FE_FLAG_DYNAMIC 0x01
124 #define VXLAN_FE_FLAG_STATIC 0x02
126 #define VXLAN_FE_IS_DYNAMIC(_fe) \
127 ((_fe)->vxlfe_flags & VXLAN_FE_FLAG_DYNAMIC)
129 #define VXLAN_SC_FTABLE_SHIFT 9
130 #define VXLAN_SC_FTABLE_SIZE (1 << VXLAN_SC_FTABLE_SHIFT)
131 #define VXLAN_SC_FTABLE_MASK (VXLAN_SC_FTABLE_SIZE - 1)
132 #define VXLAN_SC_FTABLE_HASH(_sc, _mac) \
133 (vxlan_mac_hash(_sc, _mac) % VXLAN_SC_FTABLE_SIZE)
135 LIST_HEAD(vxlan_ftable_head, vxlan_ftable_entry);
137 struct vxlan_statistics {
138 uint32_t ftable_nospace;
139 uint32_t ftable_lock_upgrade_failed;
143 struct ifnet *vxl_ifp;
144 struct vxlan_socket *vxl_sock;
146 union vxlan_sockaddr vxl_src_addr;
147 union vxlan_sockaddr vxl_dst_addr;
149 #define VXLAN_FLAG_INIT 0x0001
150 #define VXLAN_FLAG_TEARDOWN 0x0002
151 #define VXLAN_FLAG_LEARN 0x0004
153 uint32_t vxl_port_hash_key;
154 uint16_t vxl_min_port;
155 uint16_t vxl_max_port;
158 /* Lookup table from MAC address to forwarding entry. */
159 uint32_t vxl_ftable_cnt;
160 uint32_t vxl_ftable_max;
161 uint32_t vxl_ftable_timeout;
162 uint32_t vxl_ftable_hash_key;
163 struct vxlan_ftable_head *vxl_ftable;
165 /* Derived from vxl_dst_addr. */
166 struct vxlan_ftable_entry vxl_default_fe;
168 struct ip_moptions *vxl_im4o;
169 struct ip6_moptions *vxl_im6o;
171 struct rmlock vxl_lock;
172 volatile u_int vxl_refcnt;
175 int vxl_vso_mc_index;
176 struct vxlan_statistics vxl_stats;
177 struct sysctl_oid *vxl_sysctl_node;
178 struct sysctl_ctx_list vxl_sysctl_ctx;
179 struct callout vxl_callout;
180 struct ether_addr vxl_hwaddr;
182 struct ifnet *vxl_mc_ifp;
183 struct ifmedia vxl_media;
184 char vxl_mc_ifname[IFNAMSIZ];
185 LIST_ENTRY(vxlan_softc) vxl_entry;
186 LIST_ENTRY(vxlan_softc) vxl_ifdetach_list;
189 #define VXLAN_RLOCK(_sc, _p) rm_rlock(&(_sc)->vxl_lock, (_p))
190 #define VXLAN_RUNLOCK(_sc, _p) rm_runlock(&(_sc)->vxl_lock, (_p))
191 #define VXLAN_WLOCK(_sc) rm_wlock(&(_sc)->vxl_lock)
192 #define VXLAN_WUNLOCK(_sc) rm_wunlock(&(_sc)->vxl_lock)
193 #define VXLAN_LOCK_WOWNED(_sc) rm_wowned(&(_sc)->vxl_lock)
194 #define VXLAN_LOCK_ASSERT(_sc) rm_assert(&(_sc)->vxl_lock, RA_LOCKED)
195 #define VXLAN_LOCK_WASSERT(_sc) rm_assert(&(_sc)->vxl_lock, RA_WLOCKED)
196 #define VXLAN_UNLOCK(_sc, _p) do { \
197 if (VXLAN_LOCK_WOWNED(_sc)) \
198 VXLAN_WUNLOCK(_sc); \
200 VXLAN_RUNLOCK(_sc, _p); \
203 #define VXLAN_ACQUIRE(_sc) refcount_acquire(&(_sc)->vxl_refcnt)
204 #define VXLAN_RELEASE(_sc) refcount_release(&(_sc)->vxl_refcnt)
206 #define satoconstsin(sa) ((const struct sockaddr_in *)(sa))
207 #define satoconstsin6(sa) ((const struct sockaddr_in6 *)(sa))
210 struct udphdr vxlh_udp;
211 struct vxlan_header vxlh_hdr;
214 static int vxlan_ftable_addr_cmp(const uint8_t *, const uint8_t *);
215 static void vxlan_ftable_init(struct vxlan_softc *);
216 static void vxlan_ftable_fini(struct vxlan_softc *);
217 static void vxlan_ftable_flush(struct vxlan_softc *, int);
218 static void vxlan_ftable_expire(struct vxlan_softc *);
219 static int vxlan_ftable_update_locked(struct vxlan_softc *,
220 const union vxlan_sockaddr *, const uint8_t *,
221 struct rm_priotracker *);
222 static int vxlan_ftable_learn(struct vxlan_softc *,
223 const struct sockaddr *, const uint8_t *);
224 static int vxlan_ftable_sysctl_dump(SYSCTL_HANDLER_ARGS);
226 static struct vxlan_ftable_entry *
227 vxlan_ftable_entry_alloc(void);
228 static void vxlan_ftable_entry_free(struct vxlan_ftable_entry *);
229 static void vxlan_ftable_entry_init(struct vxlan_softc *,
230 struct vxlan_ftable_entry *, const uint8_t *,
231 const struct sockaddr *, uint32_t);
232 static void vxlan_ftable_entry_destroy(struct vxlan_softc *,
233 struct vxlan_ftable_entry *);
234 static int vxlan_ftable_entry_insert(struct vxlan_softc *,
235 struct vxlan_ftable_entry *);
236 static struct vxlan_ftable_entry *
237 vxlan_ftable_entry_lookup(struct vxlan_softc *,
239 static void vxlan_ftable_entry_dump(struct vxlan_ftable_entry *,
242 static struct vxlan_socket *
243 vxlan_socket_alloc(const union vxlan_sockaddr *);
244 static void vxlan_socket_destroy(struct vxlan_socket *);
245 static void vxlan_socket_release(struct vxlan_socket *);
246 static struct vxlan_socket *
247 vxlan_socket_lookup(union vxlan_sockaddr *vxlsa);
248 static void vxlan_socket_insert(struct vxlan_socket *);
249 static int vxlan_socket_init(struct vxlan_socket *, struct ifnet *);
250 static int vxlan_socket_bind(struct vxlan_socket *, struct ifnet *);
251 static int vxlan_socket_create(struct ifnet *, int,
252 const union vxlan_sockaddr *, struct vxlan_socket **);
253 static void vxlan_socket_ifdetach(struct vxlan_socket *,
254 struct ifnet *, struct vxlan_softc_head *);
256 static struct vxlan_socket *
257 vxlan_socket_mc_lookup(const union vxlan_sockaddr *);
258 static int vxlan_sockaddr_mc_info_match(
259 const struct vxlan_socket_mc_info *,
260 const union vxlan_sockaddr *,
261 const union vxlan_sockaddr *, int);
262 static int vxlan_socket_mc_join_group(struct vxlan_socket *,
263 const union vxlan_sockaddr *, const union vxlan_sockaddr *,
264 int *, union vxlan_sockaddr *);
265 static int vxlan_socket_mc_leave_group(struct vxlan_socket *,
266 const union vxlan_sockaddr *,
267 const union vxlan_sockaddr *, int);
268 static int vxlan_socket_mc_add_group(struct vxlan_socket *,
269 const union vxlan_sockaddr *, const union vxlan_sockaddr *,
271 static void vxlan_socket_mc_release_group_by_idx(struct vxlan_socket *,
274 static struct vxlan_softc *
275 vxlan_socket_lookup_softc_locked(struct vxlan_socket *,
277 static struct vxlan_softc *
278 vxlan_socket_lookup_softc(struct vxlan_socket *, uint32_t);
279 static int vxlan_socket_insert_softc(struct vxlan_socket *,
280 struct vxlan_softc *);
281 static void vxlan_socket_remove_softc(struct vxlan_socket *,
282 struct vxlan_softc *);
284 static struct ifnet *
285 vxlan_multicast_if_ref(struct vxlan_softc *, int);
286 static void vxlan_free_multicast(struct vxlan_softc *);
287 static int vxlan_setup_multicast_interface(struct vxlan_softc *);
289 static int vxlan_setup_multicast(struct vxlan_softc *);
290 static int vxlan_setup_socket(struct vxlan_softc *);
291 static void vxlan_setup_interface(struct vxlan_softc *);
292 static int vxlan_valid_init_config(struct vxlan_softc *);
293 static void vxlan_init_wait(struct vxlan_softc *);
294 static void vxlan_init_complete(struct vxlan_softc *);
295 static void vxlan_init(void *);
296 static void vxlan_release(struct vxlan_softc *);
297 static void vxlan_teardown_wait(struct vxlan_softc *);
298 static void vxlan_teardown_complete(struct vxlan_softc *);
299 static void vxlan_teardown_locked(struct vxlan_softc *);
300 static void vxlan_teardown(struct vxlan_softc *);
301 static void vxlan_ifdetach(struct vxlan_softc *, struct ifnet *,
302 struct vxlan_softc_head *);
303 static void vxlan_timer(void *);
305 static int vxlan_ctrl_get_config(struct vxlan_softc *, void *);
306 static int vxlan_ctrl_set_vni(struct vxlan_softc *, void *);
307 static int vxlan_ctrl_set_local_addr(struct vxlan_softc *, void *);
308 static int vxlan_ctrl_set_remote_addr(struct vxlan_softc *, void *);
309 static int vxlan_ctrl_set_local_port(struct vxlan_softc *, void *);
310 static int vxlan_ctrl_set_remote_port(struct vxlan_softc *, void *);
311 static int vxlan_ctrl_set_port_range(struct vxlan_softc *, void *);
312 static int vxlan_ctrl_set_ftable_timeout(struct vxlan_softc *, void *);
313 static int vxlan_ctrl_set_ftable_max(struct vxlan_softc *, void *);
314 static int vxlan_ctrl_set_multicast_if(struct vxlan_softc * , void *);
315 static int vxlan_ctrl_set_ttl(struct vxlan_softc *, void *);
316 static int vxlan_ctrl_set_learn(struct vxlan_softc *, void *);
317 static int vxlan_ctrl_ftable_entry_add(struct vxlan_softc *, void *);
318 static int vxlan_ctrl_ftable_entry_rem(struct vxlan_softc *, void *);
319 static int vxlan_ctrl_flush(struct vxlan_softc *, void *);
320 static int vxlan_ioctl_drvspec(struct vxlan_softc *,
321 struct ifdrv *, int);
322 static int vxlan_ioctl_ifflags(struct vxlan_softc *);
323 static int vxlan_ioctl(struct ifnet *, u_long, caddr_t);
325 #if defined(INET) || defined(INET6)
326 static uint16_t vxlan_pick_source_port(struct vxlan_softc *, struct mbuf *);
327 static void vxlan_encap_header(struct vxlan_softc *, struct mbuf *,
328 int, uint16_t, uint16_t);
330 static int vxlan_encap4(struct vxlan_softc *,
331 const union vxlan_sockaddr *, struct mbuf *);
332 static int vxlan_encap6(struct vxlan_softc *,
333 const union vxlan_sockaddr *, struct mbuf *);
334 static int vxlan_transmit(struct ifnet *, struct mbuf *);
335 static void vxlan_qflush(struct ifnet *);
336 static void vxlan_rcv_udp_packet(struct mbuf *, int, struct inpcb *,
337 const struct sockaddr *, void *);
338 static int vxlan_input(struct vxlan_socket *, uint32_t, struct mbuf **,
339 const struct sockaddr *);
341 static void vxlan_set_default_config(struct vxlan_softc *);
342 static int vxlan_set_user_config(struct vxlan_softc *,
343 struct ifvxlanparam *);
344 static int vxlan_clone_create(struct if_clone *, int, caddr_t);
345 static void vxlan_clone_destroy(struct ifnet *);
347 static uint32_t vxlan_mac_hash(struct vxlan_softc *, const uint8_t *);
348 static int vxlan_media_change(struct ifnet *);
349 static void vxlan_media_status(struct ifnet *, struct ifmediareq *);
351 static int vxlan_sockaddr_cmp(const union vxlan_sockaddr *,
352 const struct sockaddr *);
353 static void vxlan_sockaddr_copy(union vxlan_sockaddr *,
354 const struct sockaddr *);
355 static int vxlan_sockaddr_in_equal(const union vxlan_sockaddr *,
356 const struct sockaddr *);
357 static void vxlan_sockaddr_in_copy(union vxlan_sockaddr *,
358 const struct sockaddr *);
359 static int vxlan_sockaddr_supported(const union vxlan_sockaddr *, int);
360 static int vxlan_sockaddr_in_any(const union vxlan_sockaddr *);
361 static int vxlan_sockaddr_in_multicast(const union vxlan_sockaddr *);
362 static int vxlan_sockaddr_in6_embedscope(union vxlan_sockaddr *);
364 static int vxlan_can_change_config(struct vxlan_softc *);
365 static int vxlan_check_vni(uint32_t);
366 static int vxlan_check_ttl(int);
367 static int vxlan_check_ftable_timeout(uint32_t);
368 static int vxlan_check_ftable_max(uint32_t);
370 static void vxlan_sysctl_setup(struct vxlan_softc *);
371 static void vxlan_sysctl_destroy(struct vxlan_softc *);
372 static int vxlan_tunable_int(struct vxlan_softc *, const char *, int);
374 static void vxlan_ifdetach_event(void *, struct ifnet *);
375 static void vxlan_load(void);
376 static void vxlan_unload(void);
377 static int vxlan_modevent(module_t, int, void *);
379 static const char vxlan_name[] = "vxlan";
380 static MALLOC_DEFINE(M_VXLAN, vxlan_name,
381 "Virtual eXtensible LAN Interface");
382 static struct if_clone *vxlan_cloner;
384 static struct mtx vxlan_list_mtx;
385 #define VXLAN_LIST_LOCK() mtx_lock(&vxlan_list_mtx)
386 #define VXLAN_LIST_UNLOCK() mtx_unlock(&vxlan_list_mtx)
388 static LIST_HEAD(, vxlan_socket) vxlan_socket_list;
390 static eventhandler_tag vxlan_ifdetach_event_tag;
392 SYSCTL_DECL(_net_link);
393 SYSCTL_NODE(_net_link, OID_AUTO, vxlan, CTLFLAG_RW, 0,
394 "Virtual eXtensible Local Area Network");
396 static int vxlan_legacy_port = 0;
397 TUNABLE_INT("net.link.vxlan.legacy_port", &vxlan_legacy_port);
398 static int vxlan_reuse_port = 0;
399 TUNABLE_INT("net.link.vxlan.reuse_port", &vxlan_reuse_port);
401 /* Default maximum number of addresses in the forwarding table. */
402 #ifndef VXLAN_FTABLE_MAX
403 #define VXLAN_FTABLE_MAX 2000
406 /* Timeout (in seconds) of addresses learned in the forwarding table. */
407 #ifndef VXLAN_FTABLE_TIMEOUT
408 #define VXLAN_FTABLE_TIMEOUT (20 * 60)
412 * Maximum timeout (in seconds) of addresses learned in the forwarding
415 #ifndef VXLAN_FTABLE_MAX_TIMEOUT
416 #define VXLAN_FTABLE_MAX_TIMEOUT (60 * 60 * 24)
419 /* Number of seconds between pruning attempts of the forwarding table. */
420 #ifndef VXLAN_FTABLE_PRUNE
421 #define VXLAN_FTABLE_PRUNE (5 * 60)
424 static int vxlan_ftable_prune_period = VXLAN_FTABLE_PRUNE;
426 struct vxlan_control {
427 int (*vxlc_func)(struct vxlan_softc *, void *);
430 #define VXLAN_CTRL_FLAG_COPYIN 0x01
431 #define VXLAN_CTRL_FLAG_COPYOUT 0x02
432 #define VXLAN_CTRL_FLAG_SUSER 0x04
435 static const struct vxlan_control vxlan_control_table[] = {
436 [VXLAN_CMD_GET_CONFIG] =
437 { vxlan_ctrl_get_config, sizeof(struct ifvxlancfg),
438 VXLAN_CTRL_FLAG_COPYOUT
441 [VXLAN_CMD_SET_VNI] =
442 { vxlan_ctrl_set_vni, sizeof(struct ifvxlancmd),
443 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
446 [VXLAN_CMD_SET_LOCAL_ADDR] =
447 { vxlan_ctrl_set_local_addr, sizeof(struct ifvxlancmd),
448 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
451 [VXLAN_CMD_SET_REMOTE_ADDR] =
452 { vxlan_ctrl_set_remote_addr, sizeof(struct ifvxlancmd),
453 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
456 [VXLAN_CMD_SET_LOCAL_PORT] =
457 { vxlan_ctrl_set_local_port, sizeof(struct ifvxlancmd),
458 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
461 [VXLAN_CMD_SET_REMOTE_PORT] =
462 { vxlan_ctrl_set_remote_port, sizeof(struct ifvxlancmd),
463 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
466 [VXLAN_CMD_SET_PORT_RANGE] =
467 { vxlan_ctrl_set_port_range, sizeof(struct ifvxlancmd),
468 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
471 [VXLAN_CMD_SET_FTABLE_TIMEOUT] =
472 { vxlan_ctrl_set_ftable_timeout, sizeof(struct ifvxlancmd),
473 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
476 [VXLAN_CMD_SET_FTABLE_MAX] =
477 { vxlan_ctrl_set_ftable_max, sizeof(struct ifvxlancmd),
478 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
481 [VXLAN_CMD_SET_MULTICAST_IF] =
482 { vxlan_ctrl_set_multicast_if, sizeof(struct ifvxlancmd),
483 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
486 [VXLAN_CMD_SET_TTL] =
487 { vxlan_ctrl_set_ttl, sizeof(struct ifvxlancmd),
488 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
491 [VXLAN_CMD_SET_LEARN] =
492 { vxlan_ctrl_set_learn, sizeof(struct ifvxlancmd),
493 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
496 [VXLAN_CMD_FTABLE_ENTRY_ADD] =
497 { vxlan_ctrl_ftable_entry_add, sizeof(struct ifvxlancmd),
498 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
501 [VXLAN_CMD_FTABLE_ENTRY_REM] =
502 { vxlan_ctrl_ftable_entry_rem, sizeof(struct ifvxlancmd),
503 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
507 { vxlan_ctrl_flush, sizeof(struct ifvxlancmd),
508 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
512 static const int vxlan_control_table_size = nitems(vxlan_control_table);
515 vxlan_ftable_addr_cmp(const uint8_t *a, const uint8_t *b)
519 for (i = 0, d = 0; i < ETHER_ADDR_LEN && d == 0; i++)
520 d = ((int)a[i]) - ((int)b[i]);
526 vxlan_ftable_init(struct vxlan_softc *sc)
530 sc->vxl_ftable = malloc(sizeof(struct vxlan_ftable_head) *
531 VXLAN_SC_FTABLE_SIZE, M_VXLAN, M_ZERO | M_WAITOK);
533 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++)
534 LIST_INIT(&sc->vxl_ftable[i]);
535 sc->vxl_ftable_hash_key = arc4random();
539 vxlan_ftable_fini(struct vxlan_softc *sc)
543 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
544 KASSERT(LIST_EMPTY(&sc->vxl_ftable[i]),
545 ("%s: vxlan %p ftable[%d] not empty", __func__, sc, i));
547 MPASS(sc->vxl_ftable_cnt == 0);
549 free(sc->vxl_ftable, M_VXLAN);
550 sc->vxl_ftable = NULL;
554 vxlan_ftable_flush(struct vxlan_softc *sc, int all)
556 struct vxlan_ftable_entry *fe, *tfe;
559 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
560 LIST_FOREACH_SAFE(fe, &sc->vxl_ftable[i], vxlfe_hash, tfe) {
561 if (all || VXLAN_FE_IS_DYNAMIC(fe))
562 vxlan_ftable_entry_destroy(sc, fe);
568 vxlan_ftable_expire(struct vxlan_softc *sc)
570 struct vxlan_ftable_entry *fe, *tfe;
573 VXLAN_LOCK_WASSERT(sc);
575 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
576 LIST_FOREACH_SAFE(fe, &sc->vxl_ftable[i], vxlfe_hash, tfe) {
577 if (VXLAN_FE_IS_DYNAMIC(fe) &&
578 time_uptime >= fe->vxlfe_expire)
579 vxlan_ftable_entry_destroy(sc, fe);
585 vxlan_ftable_update_locked(struct vxlan_softc *sc,
586 const union vxlan_sockaddr *vxlsa, const uint8_t *mac,
587 struct rm_priotracker *tracker)
589 struct vxlan_ftable_entry *fe;
592 VXLAN_LOCK_ASSERT(sc);
596 * A forwarding entry for this MAC address might already exist. If
597 * so, update it, otherwise create a new one. We may have to upgrade
598 * the lock if we have to change or create an entry.
600 fe = vxlan_ftable_entry_lookup(sc, mac);
602 fe->vxlfe_expire = time_uptime + sc->vxl_ftable_timeout;
604 if (!VXLAN_FE_IS_DYNAMIC(fe) ||
605 vxlan_sockaddr_in_equal(&fe->vxlfe_raddr, &vxlsa->sa))
607 if (!VXLAN_LOCK_WOWNED(sc)) {
608 VXLAN_RUNLOCK(sc, tracker);
610 sc->vxl_stats.ftable_lock_upgrade_failed++;
613 vxlan_sockaddr_in_copy(&fe->vxlfe_raddr, &vxlsa->sa);
617 if (!VXLAN_LOCK_WOWNED(sc)) {
618 VXLAN_RUNLOCK(sc, tracker);
620 sc->vxl_stats.ftable_lock_upgrade_failed++;
624 if (sc->vxl_ftable_cnt >= sc->vxl_ftable_max) {
625 sc->vxl_stats.ftable_nospace++;
629 fe = vxlan_ftable_entry_alloc();
633 vxlan_ftable_entry_init(sc, fe, mac, &vxlsa->sa, VXLAN_FE_FLAG_DYNAMIC);
635 /* The prior lookup failed, so the insert should not. */
636 error = vxlan_ftable_entry_insert(sc, fe);
643 vxlan_ftable_learn(struct vxlan_softc *sc, const struct sockaddr *sa,
646 struct rm_priotracker tracker;
647 union vxlan_sockaddr vxlsa;
651 * The source port may be randomly selected by the remote host, so
652 * use the port of the default destination address.
654 vxlan_sockaddr_copy(&vxlsa, sa);
655 vxlsa.in4.sin_port = sc->vxl_dst_addr.in4.sin_port;
657 if (VXLAN_SOCKADDR_IS_IPV6(&vxlsa)) {
658 error = vxlan_sockaddr_in6_embedscope(&vxlsa);
663 VXLAN_RLOCK(sc, &tracker);
664 error = vxlan_ftable_update_locked(sc, &vxlsa, mac, &tracker);
665 VXLAN_UNLOCK(sc, &tracker);
671 vxlan_ftable_sysctl_dump(SYSCTL_HANDLER_ARGS)
673 struct rm_priotracker tracker;
675 struct vxlan_softc *sc;
676 struct vxlan_ftable_entry *fe;
681 * This is mostly intended for debugging during development. It is
682 * not practical to dump an entire large table this way.
686 size = PAGE_SIZE; /* Calculate later. */
688 sbuf_new(&sb, NULL, size, SBUF_FIXEDLEN);
689 sbuf_putc(&sb, '\n');
691 VXLAN_RLOCK(sc, &tracker);
692 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
693 LIST_FOREACH(fe, &sc->vxl_ftable[i], vxlfe_hash) {
694 if (sbuf_error(&sb) != 0)
696 vxlan_ftable_entry_dump(fe, &sb);
699 VXLAN_RUNLOCK(sc, &tracker);
701 if (sbuf_len(&sb) == 1)
705 error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
711 static struct vxlan_ftable_entry *
712 vxlan_ftable_entry_alloc(void)
714 struct vxlan_ftable_entry *fe;
716 fe = malloc(sizeof(*fe), M_VXLAN, M_ZERO | M_NOWAIT);
722 vxlan_ftable_entry_free(struct vxlan_ftable_entry *fe)
729 vxlan_ftable_entry_init(struct vxlan_softc *sc, struct vxlan_ftable_entry *fe,
730 const uint8_t *mac, const struct sockaddr *sa, uint32_t flags)
733 fe->vxlfe_flags = flags;
734 fe->vxlfe_expire = time_uptime + sc->vxl_ftable_timeout;
735 memcpy(fe->vxlfe_mac, mac, ETHER_ADDR_LEN);
736 vxlan_sockaddr_copy(&fe->vxlfe_raddr, sa);
740 vxlan_ftable_entry_destroy(struct vxlan_softc *sc,
741 struct vxlan_ftable_entry *fe)
744 sc->vxl_ftable_cnt--;
745 LIST_REMOVE(fe, vxlfe_hash);
746 vxlan_ftable_entry_free(fe);
750 vxlan_ftable_entry_insert(struct vxlan_softc *sc,
751 struct vxlan_ftable_entry *fe)
753 struct vxlan_ftable_entry *lfe;
757 VXLAN_LOCK_WASSERT(sc);
758 hash = VXLAN_SC_FTABLE_HASH(sc, fe->vxlfe_mac);
760 lfe = LIST_FIRST(&sc->vxl_ftable[hash]);
762 LIST_INSERT_HEAD(&sc->vxl_ftable[hash], fe, vxlfe_hash);
767 dir = vxlan_ftable_addr_cmp(fe->vxlfe_mac, lfe->vxlfe_mac);
771 LIST_INSERT_BEFORE(lfe, fe, vxlfe_hash);
773 } else if (LIST_NEXT(lfe, vxlfe_hash) == NULL) {
774 LIST_INSERT_AFTER(lfe, fe, vxlfe_hash);
777 lfe = LIST_NEXT(lfe, vxlfe_hash);
778 } while (lfe != NULL);
781 sc->vxl_ftable_cnt++;
786 static struct vxlan_ftable_entry *
787 vxlan_ftable_entry_lookup(struct vxlan_softc *sc, const uint8_t *mac)
789 struct vxlan_ftable_entry *fe;
793 VXLAN_LOCK_ASSERT(sc);
794 hash = VXLAN_SC_FTABLE_HASH(sc, mac);
796 LIST_FOREACH(fe, &sc->vxl_ftable[hash], vxlfe_hash) {
797 dir = vxlan_ftable_addr_cmp(mac, fe->vxlfe_mac);
808 vxlan_ftable_entry_dump(struct vxlan_ftable_entry *fe, struct sbuf *sb)
811 const union vxlan_sockaddr *sa;
813 int i, len, af, width;
815 sa = &fe->vxlfe_raddr;
816 af = sa->sa.sa_family;
819 sbuf_printf(sb, "%c 0x%02X ", VXLAN_FE_IS_DYNAMIC(fe) ? 'D' : 'S',
822 for (i = 0; i < ETHER_ADDR_LEN - 1; i++)
823 sbuf_printf(sb, "%02X:", fe->vxlfe_mac[i]);
824 sbuf_printf(sb, "%02X ", fe->vxlfe_mac[i]);
827 addr = &sa->in4.sin_addr;
828 width = INET_ADDRSTRLEN - 1;
830 addr = &sa->in6.sin6_addr;
831 width = INET6_ADDRSTRLEN - 1;
833 inet_ntop(af, addr, buf, sizeof(buf));
834 sbuf_printf(sb, "%*s ", width, buf);
836 sbuf_printf(sb, "%08jd", (intmax_t)fe->vxlfe_expire);
840 /* Truncate a partial line. */
841 if (sbuf_error(sb) != 0)
842 sbuf_setpos(sb, len);
845 static struct vxlan_socket *
846 vxlan_socket_alloc(const union vxlan_sockaddr *sa)
848 struct vxlan_socket *vso;
851 vso = malloc(sizeof(*vso), M_VXLAN, M_WAITOK | M_ZERO);
852 rm_init(&vso->vxlso_lock, "vxlansorm");
853 refcount_init(&vso->vxlso_refcnt, 0);
854 for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++)
855 LIST_INIT(&vso->vxlso_vni_hash[i]);
856 vso->vxlso_laddr = *sa;
862 vxlan_socket_destroy(struct vxlan_socket *vso)
865 struct vxlan_socket_mc_info *mc;
868 for (i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
869 mc = &vso->vxlso_mc[i];
870 KASSERT(mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC,
871 ("%s: socket %p mc[%d] still has address",
875 for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++) {
876 KASSERT(LIST_EMPTY(&vso->vxlso_vni_hash[i]),
877 ("%s: socket %p vni_hash[%d] not empty",
881 so = vso->vxlso_sock;
883 vso->vxlso_sock = NULL;
887 rm_destroy(&vso->vxlso_lock);
892 vxlan_socket_release(struct vxlan_socket *vso)
897 destroy = VXLAN_SO_RELEASE(vso);
899 LIST_REMOVE(vso, vxlso_entry);
903 vxlan_socket_destroy(vso);
906 static struct vxlan_socket *
907 vxlan_socket_lookup(union vxlan_sockaddr *vxlsa)
909 struct vxlan_socket *vso;
912 LIST_FOREACH(vso, &vxlan_socket_list, vxlso_entry) {
913 if (vxlan_sockaddr_cmp(&vso->vxlso_laddr, &vxlsa->sa) == 0) {
914 VXLAN_SO_ACQUIRE(vso);
924 vxlan_socket_insert(struct vxlan_socket *vso)
928 VXLAN_SO_ACQUIRE(vso);
929 LIST_INSERT_HEAD(&vxlan_socket_list, vso, vxlso_entry);
934 vxlan_socket_init(struct vxlan_socket *vso, struct ifnet *ifp)
941 error = socreate(vso->vxlso_laddr.sa.sa_family, &vso->vxlso_sock,
942 SOCK_DGRAM, IPPROTO_UDP, td->td_ucred, td);
944 if_printf(ifp, "cannot create socket: %d\n", error);
948 error = udp_set_kernel_tunneling(vso->vxlso_sock,
949 vxlan_rcv_udp_packet, NULL, vso);
951 if_printf(ifp, "cannot set tunneling function: %d\n", error);
955 if (vxlan_reuse_port != 0) {
959 bzero(&sopt, sizeof(sopt));
960 sopt.sopt_dir = SOPT_SET;
961 sopt.sopt_level = IPPROTO_IP;
962 sopt.sopt_name = SO_REUSEPORT;
963 sopt.sopt_val = &val;
964 sopt.sopt_valsize = sizeof(val);
965 error = sosetopt(vso->vxlso_sock, &sopt);
968 "cannot set REUSEADDR socket opt: %d\n", error);
977 vxlan_socket_bind(struct vxlan_socket *vso, struct ifnet *ifp)
979 union vxlan_sockaddr laddr;
984 laddr = vso->vxlso_laddr;
986 error = sobind(vso->vxlso_sock, &laddr.sa, td);
988 if (error != EADDRINUSE)
989 if_printf(ifp, "cannot bind socket: %d\n", error);
997 vxlan_socket_create(struct ifnet *ifp, int multicast,
998 const union vxlan_sockaddr *saddr, struct vxlan_socket **vsop)
1000 union vxlan_sockaddr laddr;
1001 struct vxlan_socket *vso;
1007 * If this socket will be multicast, then only the local port
1008 * must be specified when binding.
1010 if (multicast != 0) {
1011 if (VXLAN_SOCKADDR_IS_IPV4(&laddr))
1012 laddr.in4.sin_addr.s_addr = INADDR_ANY;
1015 laddr.in6.sin6_addr = in6addr_any;
1019 vso = vxlan_socket_alloc(&laddr);
1023 error = vxlan_socket_init(vso, ifp);
1027 error = vxlan_socket_bind(vso, ifp);
1032 * There is a small window between the bind completing and
1033 * inserting the socket, so that a concurrent create may fail.
1034 * Let's not worry about that for now.
1036 vxlan_socket_insert(vso);
1042 vxlan_socket_destroy(vso);
1048 vxlan_socket_ifdetach(struct vxlan_socket *vso, struct ifnet *ifp,
1049 struct vxlan_softc_head *list)
1051 struct rm_priotracker tracker;
1052 struct vxlan_softc *sc;
1055 VXLAN_SO_RLOCK(vso, &tracker);
1056 for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++) {
1057 LIST_FOREACH(sc, &vso->vxlso_vni_hash[i], vxl_entry)
1058 vxlan_ifdetach(sc, ifp, list);
1060 VXLAN_SO_RUNLOCK(vso, &tracker);
1063 static struct vxlan_socket *
1064 vxlan_socket_mc_lookup(const union vxlan_sockaddr *vxlsa)
1066 union vxlan_sockaddr laddr;
1067 struct vxlan_socket *vso;
1071 if (VXLAN_SOCKADDR_IS_IPV4(&laddr))
1072 laddr.in4.sin_addr.s_addr = INADDR_ANY;
1075 laddr.in6.sin6_addr = in6addr_any;
1078 vso = vxlan_socket_lookup(&laddr);
1084 vxlan_sockaddr_mc_info_match(const struct vxlan_socket_mc_info *mc,
1085 const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1089 if (!vxlan_sockaddr_in_any(local) &&
1090 !vxlan_sockaddr_in_equal(&mc->vxlsomc_saddr, &local->sa))
1092 if (!vxlan_sockaddr_in_equal(&mc->vxlsomc_gaddr, &group->sa))
1094 if (ifidx != 0 && ifidx != mc->vxlsomc_ifidx)
1101 vxlan_socket_mc_join_group(struct vxlan_socket *vso,
1102 const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1103 int *ifidx, union vxlan_sockaddr *source)
1105 struct sockopt sopt;
1110 if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1111 struct ip_mreq mreq;
1113 mreq.imr_multiaddr = group->in4.sin_addr;
1114 mreq.imr_interface = local->in4.sin_addr;
1116 bzero(&sopt, sizeof(sopt));
1117 sopt.sopt_dir = SOPT_SET;
1118 sopt.sopt_level = IPPROTO_IP;
1119 sopt.sopt_name = IP_ADD_MEMBERSHIP;
1120 sopt.sopt_val = &mreq;
1121 sopt.sopt_valsize = sizeof(mreq);
1122 error = sosetopt(vso->vxlso_sock, &sopt);
1127 * BMV: Ideally, there would be a formal way for us to get
1128 * the local interface that was selected based on the
1129 * imr_interface address. We could then update *ifidx so
1130 * vxlan_sockaddr_mc_info_match() would return a match for
1131 * later creates that explicitly set the multicast interface.
1133 * If we really need to, we can of course look in the INP's
1135 * sotoinpcb(vso->vxlso_sock)->inp_moptions->
1136 * imo_membership[]->inm_ifp
1137 * similarly to imo_match_group().
1139 source->in4.sin_addr = local->in4.sin_addr;
1141 } else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1142 struct ipv6_mreq mreq;
1144 mreq.ipv6mr_multiaddr = group->in6.sin6_addr;
1145 mreq.ipv6mr_interface = *ifidx;
1147 bzero(&sopt, sizeof(sopt));
1148 sopt.sopt_dir = SOPT_SET;
1149 sopt.sopt_level = IPPROTO_IPV6;
1150 sopt.sopt_name = IPV6_JOIN_GROUP;
1151 sopt.sopt_val = &mreq;
1152 sopt.sopt_valsize = sizeof(mreq);
1153 error = sosetopt(vso->vxlso_sock, &sopt);
1158 * BMV: As with IPv4, we would really like to know what
1159 * interface in6p_lookup_mcast_ifp() selected.
1162 error = EAFNOSUPPORT;
1168 vxlan_socket_mc_leave_group(struct vxlan_socket *vso,
1169 const union vxlan_sockaddr *group, const union vxlan_sockaddr *source,
1172 struct sockopt sopt;
1175 bzero(&sopt, sizeof(sopt));
1176 sopt.sopt_dir = SOPT_SET;
1178 if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1179 struct ip_mreq mreq;
1181 mreq.imr_multiaddr = group->in4.sin_addr;
1182 mreq.imr_interface = source->in4.sin_addr;
1184 sopt.sopt_level = IPPROTO_IP;
1185 sopt.sopt_name = IP_DROP_MEMBERSHIP;
1186 sopt.sopt_val = &mreq;
1187 sopt.sopt_valsize = sizeof(mreq);
1188 error = sosetopt(vso->vxlso_sock, &sopt);
1190 } else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1191 struct ipv6_mreq mreq;
1193 mreq.ipv6mr_multiaddr = group->in6.sin6_addr;
1194 mreq.ipv6mr_interface = ifidx;
1196 sopt.sopt_level = IPPROTO_IPV6;
1197 sopt.sopt_name = IPV6_LEAVE_GROUP;
1198 sopt.sopt_val = &mreq;
1199 sopt.sopt_valsize = sizeof(mreq);
1200 error = sosetopt(vso->vxlso_sock, &sopt);
1203 error = EAFNOSUPPORT;
1209 vxlan_socket_mc_add_group(struct vxlan_socket *vso,
1210 const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1211 int ifidx, int *idx)
1213 union vxlan_sockaddr source;
1214 struct vxlan_socket_mc_info *mc;
1215 int i, empty, error;
1218 * Within a socket, the same multicast group may be used by multiple
1219 * interfaces, each with a different network identifier. But a socket
1220 * may only join a multicast group once, so keep track of the users
1224 VXLAN_SO_WLOCK(vso);
1225 for (empty = 0, i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
1226 mc = &vso->vxlso_mc[i];
1228 if (mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC) {
1233 if (vxlan_sockaddr_mc_info_match(mc, group, local, ifidx))
1236 VXLAN_SO_WUNLOCK(vso);
1241 error = vxlan_socket_mc_join_group(vso, group, local, &ifidx, &source);
1245 VXLAN_SO_WLOCK(vso);
1246 for (i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
1247 mc = &vso->vxlso_mc[i];
1249 if (mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC) {
1250 vxlan_sockaddr_copy(&mc->vxlsomc_gaddr, &group->sa);
1251 vxlan_sockaddr_copy(&mc->vxlsomc_saddr, &source.sa);
1252 mc->vxlsomc_ifidx = ifidx;
1256 VXLAN_SO_WUNLOCK(vso);
1258 error = vxlan_socket_mc_leave_group(vso, group, &source, ifidx);
1264 mc->vxlsomc_users++;
1265 VXLAN_SO_WUNLOCK(vso);
1273 vxlan_socket_mc_release_group_by_idx(struct vxlan_socket *vso, int idx)
1275 union vxlan_sockaddr group, source;
1276 struct vxlan_socket_mc_info *mc;
1279 KASSERT(idx >= 0 && idx < VXLAN_SO_MC_MAX_GROUPS,
1280 ("%s: vso %p idx %d out of bounds", __func__, vso, idx));
1283 mc = &vso->vxlso_mc[idx];
1285 VXLAN_SO_WLOCK(vso);
1286 mc->vxlsomc_users--;
1287 if (mc->vxlsomc_users == 0) {
1288 group = mc->vxlsomc_gaddr;
1289 source = mc->vxlsomc_saddr;
1290 ifidx = mc->vxlsomc_ifidx;
1291 bzero(mc, sizeof(*mc));
1294 VXLAN_SO_WUNLOCK(vso);
1298 * Our socket's membership in this group may have already
1299 * been removed if we joined through an interface that's
1302 vxlan_socket_mc_leave_group(vso, &group, &source, ifidx);
1306 static struct vxlan_softc *
1307 vxlan_socket_lookup_softc_locked(struct vxlan_socket *vso, uint32_t vni)
1309 struct vxlan_softc *sc;
1312 VXLAN_SO_LOCK_ASSERT(vso);
1313 hash = VXLAN_SO_VNI_HASH(vni);
1315 LIST_FOREACH(sc, &vso->vxlso_vni_hash[hash], vxl_entry) {
1316 if (sc->vxl_vni == vni) {
1325 static struct vxlan_softc *
1326 vxlan_socket_lookup_softc(struct vxlan_socket *vso, uint32_t vni)
1328 struct rm_priotracker tracker;
1329 struct vxlan_softc *sc;
1331 VXLAN_SO_RLOCK(vso, &tracker);
1332 sc = vxlan_socket_lookup_softc_locked(vso, vni);
1333 VXLAN_SO_RUNLOCK(vso, &tracker);
1339 vxlan_socket_insert_softc(struct vxlan_socket *vso, struct vxlan_softc *sc)
1341 struct vxlan_softc *tsc;
1345 hash = VXLAN_SO_VNI_HASH(vni);
1347 VXLAN_SO_WLOCK(vso);
1348 tsc = vxlan_socket_lookup_softc_locked(vso, vni);
1350 VXLAN_SO_WUNLOCK(vso);
1356 LIST_INSERT_HEAD(&vso->vxlso_vni_hash[hash], sc, vxl_entry);
1357 VXLAN_SO_WUNLOCK(vso);
1363 vxlan_socket_remove_softc(struct vxlan_socket *vso, struct vxlan_softc *sc)
1366 VXLAN_SO_WLOCK(vso);
1367 LIST_REMOVE(sc, vxl_entry);
1368 VXLAN_SO_WUNLOCK(vso);
1373 static struct ifnet *
1374 vxlan_multicast_if_ref(struct vxlan_softc *sc, int ipv4)
1378 VXLAN_LOCK_ASSERT(sc);
1380 if (ipv4 && sc->vxl_im4o != NULL)
1381 ifp = sc->vxl_im4o->imo_multicast_ifp;
1382 else if (!ipv4 && sc->vxl_im6o != NULL)
1383 ifp = sc->vxl_im6o->im6o_multicast_ifp;
1394 vxlan_free_multicast(struct vxlan_softc *sc)
1397 if (sc->vxl_mc_ifp != NULL) {
1398 if_rele(sc->vxl_mc_ifp);
1399 sc->vxl_mc_ifp = NULL;
1400 sc->vxl_mc_ifindex = 0;
1403 if (sc->vxl_im4o != NULL) {
1404 free(sc->vxl_im4o, M_VXLAN);
1405 sc->vxl_im4o = NULL;
1408 if (sc->vxl_im6o != NULL) {
1409 free(sc->vxl_im6o, M_VXLAN);
1410 sc->vxl_im6o = NULL;
1415 vxlan_setup_multicast_interface(struct vxlan_softc *sc)
1419 ifp = ifunit_ref(sc->vxl_mc_ifname);
1421 if_printf(sc->vxl_ifp, "multicast interface %s does "
1422 "not exist\n", sc->vxl_mc_ifname);
1426 if ((ifp->if_flags & IFF_MULTICAST) == 0) {
1427 if_printf(sc->vxl_ifp, "interface %s does not support "
1428 "multicast\n", sc->vxl_mc_ifname);
1433 sc->vxl_mc_ifp = ifp;
1434 sc->vxl_mc_ifindex = ifp->if_index;
1440 vxlan_setup_multicast(struct vxlan_softc *sc)
1442 const union vxlan_sockaddr *group;
1445 group = &sc->vxl_dst_addr;
1448 if (sc->vxl_mc_ifname[0] != '\0') {
1449 error = vxlan_setup_multicast_interface(sc);
1455 * Initialize an multicast options structure that is sufficiently
1456 * populated for use in the respective IP output routine. This
1457 * structure is typically stored in the socket, but our sockets
1458 * may be shared among multiple interfaces.
1460 if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1461 sc->vxl_im4o = malloc(sizeof(struct ip_moptions), M_VXLAN,
1463 sc->vxl_im4o->imo_multicast_ifp = sc->vxl_mc_ifp;
1464 sc->vxl_im4o->imo_multicast_ttl = sc->vxl_ttl;
1465 sc->vxl_im4o->imo_multicast_vif = -1;
1466 } else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1467 sc->vxl_im6o = malloc(sizeof(struct ip6_moptions), M_VXLAN,
1469 sc->vxl_im6o->im6o_multicast_ifp = sc->vxl_mc_ifp;
1470 sc->vxl_im6o->im6o_multicast_hlim = sc->vxl_ttl;
1477 vxlan_setup_socket(struct vxlan_softc *sc)
1479 struct vxlan_socket *vso;
1481 union vxlan_sockaddr *saddr, *daddr;
1482 int multicast, error;
1486 saddr = &sc->vxl_src_addr;
1487 daddr = &sc->vxl_dst_addr;
1489 multicast = vxlan_sockaddr_in_multicast(daddr);
1490 MPASS(multicast != -1);
1491 sc->vxl_vso_mc_index = -1;
1494 * Try to create the socket. If that fails, attempt to use an
1497 error = vxlan_socket_create(ifp, multicast, saddr, &vso);
1500 vso = vxlan_socket_mc_lookup(saddr);
1502 vso = vxlan_socket_lookup(saddr);
1505 if_printf(ifp, "cannot create socket (error: %d), "
1506 "and no existing socket found\n", error);
1511 if (multicast != 0) {
1512 error = vxlan_setup_multicast(sc);
1516 error = vxlan_socket_mc_add_group(vso, daddr, saddr,
1517 sc->vxl_mc_ifindex, &sc->vxl_vso_mc_index);
1523 error = vxlan_socket_insert_softc(vso, sc);
1525 sc->vxl_sock = NULL;
1526 if_printf(ifp, "network identifier %d already exists in "
1527 "this socket\n", sc->vxl_vni);
1535 if (sc->vxl_vso_mc_index != -1) {
1536 vxlan_socket_mc_release_group_by_idx(vso,
1537 sc->vxl_vso_mc_index);
1538 sc->vxl_vso_mc_index = -1;
1541 vxlan_free_multicast(sc);
1542 vxlan_socket_release(vso);
1549 vxlan_setup_interface(struct vxlan_softc *sc)
1554 ifp->if_hdrlen = ETHER_HDR_LEN + sizeof(struct vxlanudphdr);
1556 if (VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_dst_addr) != 0)
1557 ifp->if_hdrlen += sizeof(struct ip);
1558 else if (VXLAN_SOCKADDR_IS_IPV6(&sc->vxl_dst_addr) != 0)
1559 ifp->if_hdrlen += sizeof(struct ip6_hdr);
1563 vxlan_valid_init_config(struct vxlan_softc *sc)
1567 if (vxlan_check_vni(sc->vxl_vni) != 0) {
1568 reason = "invalid virtual network identifier specified";
1572 if (vxlan_sockaddr_supported(&sc->vxl_src_addr, 1) == 0) {
1573 reason = "source address type is not supported";
1577 if (vxlan_sockaddr_supported(&sc->vxl_dst_addr, 0) == 0) {
1578 reason = "destination address type is not supported";
1582 if (vxlan_sockaddr_in_any(&sc->vxl_dst_addr) != 0) {
1583 reason = "no valid destination address specified";
1587 if (vxlan_sockaddr_in_multicast(&sc->vxl_dst_addr) == 0 &&
1588 sc->vxl_mc_ifname[0] != '\0') {
1589 reason = "can only specify interface with a group address";
1593 if (vxlan_sockaddr_in_any(&sc->vxl_src_addr) == 0) {
1594 if (VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_src_addr) ^
1595 VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_dst_addr)) {
1596 reason = "source and destination address must both "
1597 "be either IPv4 or IPv6";
1602 if (sc->vxl_src_addr.in4.sin_port == 0) {
1603 reason = "local port not specified";
1607 if (sc->vxl_dst_addr.in4.sin_port == 0) {
1608 reason = "remote port not specified";
1615 if_printf(sc->vxl_ifp, "cannot initialize interface: %s\n", reason);
1620 vxlan_init_wait(struct vxlan_softc *sc)
1623 VXLAN_LOCK_WASSERT(sc);
1624 while (sc->vxl_flags & VXLAN_FLAG_INIT)
1625 rm_sleep(sc, &sc->vxl_lock, 0, "vxlint", hz);
1629 vxlan_init_complete(struct vxlan_softc *sc)
1633 sc->vxl_flags &= ~VXLAN_FLAG_INIT;
1639 vxlan_init(void *xsc)
1641 static const uint8_t empty_mac[ETHER_ADDR_LEN];
1642 struct vxlan_softc *sc;
1649 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1653 sc->vxl_flags |= VXLAN_FLAG_INIT;
1656 if (vxlan_valid_init_config(sc) != 0)
1659 vxlan_setup_interface(sc);
1661 if (vxlan_setup_socket(sc) != 0)
1664 /* Initialize the default forwarding entry. */
1665 vxlan_ftable_entry_init(sc, &sc->vxl_default_fe, empty_mac,
1666 &sc->vxl_dst_addr.sa, VXLAN_FE_FLAG_STATIC);
1669 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1670 callout_reset(&sc->vxl_callout, vxlan_ftable_prune_period * hz,
1674 if_link_state_change(ifp, LINK_STATE_UP);
1676 vxlan_init_complete(sc);
1680 vxlan_release(struct vxlan_softc *sc)
1684 * The softc may be destroyed as soon as we release our reference,
1685 * so we cannot serialize the wakeup with the softc lock. We use a
1686 * timeout in our sleeps so a missed wakeup is unfortunate but not
1689 if (VXLAN_RELEASE(sc) != 0)
1694 vxlan_teardown_wait(struct vxlan_softc *sc)
1697 VXLAN_LOCK_WASSERT(sc);
1698 while (sc->vxl_flags & VXLAN_FLAG_TEARDOWN)
1699 rm_sleep(sc, &sc->vxl_lock, 0, "vxltrn", hz);
1703 vxlan_teardown_complete(struct vxlan_softc *sc)
1707 sc->vxl_flags &= ~VXLAN_FLAG_TEARDOWN;
1713 vxlan_teardown_locked(struct vxlan_softc *sc)
1716 struct vxlan_socket *vso;
1720 VXLAN_LOCK_WASSERT(sc);
1721 MPASS(sc->vxl_flags & VXLAN_FLAG_TEARDOWN);
1723 ifp->if_flags &= ~IFF_UP;
1724 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1725 callout_stop(&sc->vxl_callout);
1727 sc->vxl_sock = NULL;
1730 if_link_state_change(ifp, LINK_STATE_DOWN);
1733 vxlan_socket_remove_softc(vso, sc);
1735 if (sc->vxl_vso_mc_index != -1) {
1736 vxlan_socket_mc_release_group_by_idx(vso,
1737 sc->vxl_vso_mc_index);
1738 sc->vxl_vso_mc_index = -1;
1743 while (sc->vxl_refcnt != 0)
1744 rm_sleep(sc, &sc->vxl_lock, 0, "vxldrn", hz);
1747 callout_drain(&sc->vxl_callout);
1749 vxlan_free_multicast(sc);
1751 vxlan_socket_release(vso);
1753 vxlan_teardown_complete(sc);
1757 vxlan_teardown(struct vxlan_softc *sc)
1761 if (sc->vxl_flags & VXLAN_FLAG_TEARDOWN) {
1762 vxlan_teardown_wait(sc);
1767 sc->vxl_flags |= VXLAN_FLAG_TEARDOWN;
1768 vxlan_teardown_locked(sc);
1772 vxlan_ifdetach(struct vxlan_softc *sc, struct ifnet *ifp,
1773 struct vxlan_softc_head *list)
1778 if (sc->vxl_mc_ifp != ifp)
1780 if (sc->vxl_flags & VXLAN_FLAG_TEARDOWN)
1783 sc->vxl_flags |= VXLAN_FLAG_TEARDOWN;
1784 LIST_INSERT_HEAD(list, sc, vxl_ifdetach_list);
1791 vxlan_timer(void *xsc)
1793 struct vxlan_softc *sc;
1796 VXLAN_LOCK_WASSERT(sc);
1798 vxlan_ftable_expire(sc);
1799 callout_schedule(&sc->vxl_callout, vxlan_ftable_prune_period * hz);
1803 vxlan_ioctl_ifflags(struct vxlan_softc *sc)
1809 if (ifp->if_flags & IFF_UP) {
1810 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1813 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1821 vxlan_ctrl_get_config(struct vxlan_softc *sc, void *arg)
1823 struct rm_priotracker tracker;
1824 struct ifvxlancfg *cfg;
1827 bzero(cfg, sizeof(*cfg));
1829 VXLAN_RLOCK(sc, &tracker);
1830 cfg->vxlc_vni = sc->vxl_vni;
1831 memcpy(&cfg->vxlc_local_sa, &sc->vxl_src_addr,
1832 sizeof(union vxlan_sockaddr));
1833 memcpy(&cfg->vxlc_remote_sa, &sc->vxl_dst_addr,
1834 sizeof(union vxlan_sockaddr));
1835 cfg->vxlc_mc_ifindex = sc->vxl_mc_ifindex;
1836 cfg->vxlc_ftable_cnt = sc->vxl_ftable_cnt;
1837 cfg->vxlc_ftable_max = sc->vxl_ftable_max;
1838 cfg->vxlc_ftable_timeout = sc->vxl_ftable_timeout;
1839 cfg->vxlc_port_min = sc->vxl_min_port;
1840 cfg->vxlc_port_max = sc->vxl_max_port;
1841 cfg->vxlc_learn = (sc->vxl_flags & VXLAN_FLAG_LEARN) != 0;
1842 cfg->vxlc_ttl = sc->vxl_ttl;
1843 VXLAN_RUNLOCK(sc, &tracker);
1846 if (VXLAN_SOCKADDR_IS_IPV6(&cfg->vxlc_local_sa))
1847 sa6_recoverscope(&cfg->vxlc_local_sa.in6);
1848 if (VXLAN_SOCKADDR_IS_IPV6(&cfg->vxlc_remote_sa))
1849 sa6_recoverscope(&cfg->vxlc_remote_sa.in6);
1856 vxlan_ctrl_set_vni(struct vxlan_softc *sc, void *arg)
1858 struct ifvxlancmd *cmd;
1863 if (vxlan_check_vni(cmd->vxlcmd_vni) != 0)
1867 if (vxlan_can_change_config(sc)) {
1868 sc->vxl_vni = cmd->vxlcmd_vni;
1878 vxlan_ctrl_set_local_addr(struct vxlan_softc *sc, void *arg)
1880 struct ifvxlancmd *cmd;
1881 union vxlan_sockaddr *vxlsa;
1885 vxlsa = &cmd->vxlcmd_sa;
1887 if (!VXLAN_SOCKADDR_IS_IPV46(vxlsa))
1889 if (vxlan_sockaddr_in_multicast(vxlsa) != 0)
1891 if (VXLAN_SOCKADDR_IS_IPV6(vxlsa)) {
1892 error = vxlan_sockaddr_in6_embedscope(vxlsa);
1898 if (vxlan_can_change_config(sc)) {
1899 vxlan_sockaddr_in_copy(&sc->vxl_src_addr, &vxlsa->sa);
1909 vxlan_ctrl_set_remote_addr(struct vxlan_softc *sc, void *arg)
1911 struct ifvxlancmd *cmd;
1912 union vxlan_sockaddr *vxlsa;
1916 vxlsa = &cmd->vxlcmd_sa;
1918 if (!VXLAN_SOCKADDR_IS_IPV46(vxlsa))
1920 if (VXLAN_SOCKADDR_IS_IPV6(vxlsa)) {
1921 error = vxlan_sockaddr_in6_embedscope(vxlsa);
1927 if (vxlan_can_change_config(sc)) {
1928 vxlan_sockaddr_in_copy(&sc->vxl_dst_addr, &vxlsa->sa);
1938 vxlan_ctrl_set_local_port(struct vxlan_softc *sc, void *arg)
1940 struct ifvxlancmd *cmd;
1945 if (cmd->vxlcmd_port == 0)
1949 if (vxlan_can_change_config(sc)) {
1950 sc->vxl_src_addr.in4.sin_port = htons(cmd->vxlcmd_port);
1960 vxlan_ctrl_set_remote_port(struct vxlan_softc *sc, void *arg)
1962 struct ifvxlancmd *cmd;
1967 if (cmd->vxlcmd_port == 0)
1971 if (vxlan_can_change_config(sc)) {
1972 sc->vxl_dst_addr.in4.sin_port = htons(cmd->vxlcmd_port);
1982 vxlan_ctrl_set_port_range(struct vxlan_softc *sc, void *arg)
1984 struct ifvxlancmd *cmd;
1989 min = cmd->vxlcmd_port_min;
1990 max = cmd->vxlcmd_port_max;
1996 if (vxlan_can_change_config(sc)) {
1997 sc->vxl_min_port = min;
1998 sc->vxl_max_port = max;
2008 vxlan_ctrl_set_ftable_timeout(struct vxlan_softc *sc, void *arg)
2010 struct ifvxlancmd *cmd;
2016 if (vxlan_check_ftable_timeout(cmd->vxlcmd_ftable_timeout) == 0) {
2017 sc->vxl_ftable_timeout = cmd->vxlcmd_ftable_timeout;
2027 vxlan_ctrl_set_ftable_max(struct vxlan_softc *sc, void *arg)
2029 struct ifvxlancmd *cmd;
2035 if (vxlan_check_ftable_max(cmd->vxlcmd_ftable_max) == 0) {
2036 sc->vxl_ftable_max = cmd->vxlcmd_ftable_max;
2046 vxlan_ctrl_set_multicast_if(struct vxlan_softc * sc, void *arg)
2048 struct ifvxlancmd *cmd;
2054 if (vxlan_can_change_config(sc)) {
2055 strlcpy(sc->vxl_mc_ifname, cmd->vxlcmd_ifname, IFNAMSIZ);
2065 vxlan_ctrl_set_ttl(struct vxlan_softc *sc, void *arg)
2067 struct ifvxlancmd *cmd;
2073 if (vxlan_check_ttl(cmd->vxlcmd_ttl) == 0) {
2074 sc->vxl_ttl = cmd->vxlcmd_ttl;
2075 if (sc->vxl_im4o != NULL)
2076 sc->vxl_im4o->imo_multicast_ttl = sc->vxl_ttl;
2077 if (sc->vxl_im6o != NULL)
2078 sc->vxl_im6o->im6o_multicast_hlim = sc->vxl_ttl;
2088 vxlan_ctrl_set_learn(struct vxlan_softc *sc, void *arg)
2090 struct ifvxlancmd *cmd;
2095 if (cmd->vxlcmd_flags & VXLAN_CMD_FLAG_LEARN)
2096 sc->vxl_flags |= VXLAN_FLAG_LEARN;
2098 sc->vxl_flags &= ~VXLAN_FLAG_LEARN;
2105 vxlan_ctrl_ftable_entry_add(struct vxlan_softc *sc, void *arg)
2107 union vxlan_sockaddr vxlsa;
2108 struct ifvxlancmd *cmd;
2109 struct vxlan_ftable_entry *fe;
2113 vxlsa = cmd->vxlcmd_sa;
2115 if (!VXLAN_SOCKADDR_IS_IPV46(&vxlsa))
2117 if (vxlan_sockaddr_in_any(&vxlsa) != 0)
2119 if (vxlan_sockaddr_in_multicast(&vxlsa) != 0)
2121 /* BMV: We could support both IPv4 and IPv6 later. */
2122 if (vxlsa.sa.sa_family != sc->vxl_dst_addr.sa.sa_family)
2123 return (EAFNOSUPPORT);
2125 if (VXLAN_SOCKADDR_IS_IPV6(&vxlsa)) {
2126 error = vxlan_sockaddr_in6_embedscope(&vxlsa);
2131 fe = vxlan_ftable_entry_alloc();
2135 if (vxlsa.in4.sin_port == 0)
2136 vxlsa.in4.sin_port = sc->vxl_dst_addr.in4.sin_port;
2138 vxlan_ftable_entry_init(sc, fe, cmd->vxlcmd_mac, &vxlsa.sa,
2139 VXLAN_FE_FLAG_STATIC);
2142 error = vxlan_ftable_entry_insert(sc, fe);
2146 vxlan_ftable_entry_free(fe);
2152 vxlan_ctrl_ftable_entry_rem(struct vxlan_softc *sc, void *arg)
2154 struct ifvxlancmd *cmd;
2155 struct vxlan_ftable_entry *fe;
2161 fe = vxlan_ftable_entry_lookup(sc, cmd->vxlcmd_mac);
2163 vxlan_ftable_entry_destroy(sc, fe);
2173 vxlan_ctrl_flush(struct vxlan_softc *sc, void *arg)
2175 struct ifvxlancmd *cmd;
2179 all = cmd->vxlcmd_flags & VXLAN_CMD_FLAG_FLUSH_ALL;
2182 vxlan_ftable_flush(sc, all);
2189 vxlan_ioctl_drvspec(struct vxlan_softc *sc, struct ifdrv *ifd, int get)
2191 const struct vxlan_control *vc;
2193 struct ifvxlancfg cfg;
2194 struct ifvxlancmd cmd;
2198 if (ifd->ifd_cmd >= vxlan_control_table_size)
2201 bzero(&args, sizeof(args));
2202 vc = &vxlan_control_table[ifd->ifd_cmd];
2203 out = (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYOUT) != 0;
2205 if ((get != 0 && out == 0) || (get == 0 && out != 0))
2208 if (vc->vxlc_flags & VXLAN_CTRL_FLAG_SUSER) {
2209 error = priv_check(curthread, PRIV_NET_VXLAN);
2214 if (ifd->ifd_len != vc->vxlc_argsize ||
2215 ifd->ifd_len > sizeof(args))
2218 if (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYIN) {
2219 error = copyin(ifd->ifd_data, &args, ifd->ifd_len);
2224 error = vc->vxlc_func(sc, &args);
2228 if (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYOUT) {
2229 error = copyout(&args, ifd->ifd_data, ifd->ifd_len);
2238 vxlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2240 struct vxlan_softc *sc;
2246 ifr = (struct ifreq *) data;
2247 ifd = (struct ifdrv *) data;
2257 error = vxlan_ioctl_drvspec(sc, ifd, cmd == SIOCGDRVSPEC);
2261 error = vxlan_ioctl_ifflags(sc);
2266 error = ifmedia_ioctl(ifp, ifr, &sc->vxl_media, cmd);
2270 error = ether_ioctl(ifp, cmd, data);
2277 #if defined(INET) || defined(INET6)
2279 vxlan_pick_source_port(struct vxlan_softc *sc, struct mbuf *m)
2284 range = sc->vxl_max_port - sc->vxl_min_port + 1;
2286 if (M_HASHTYPE_ISHASH(m))
2287 hash = m->m_pkthdr.flowid;
2289 hash = jenkins_hash(m->m_data, ETHER_HDR_LEN,
2290 sc->vxl_port_hash_key);
2292 return (sc->vxl_min_port + (hash % range));
2296 vxlan_encap_header(struct vxlan_softc *sc, struct mbuf *m, int ipoff,
2297 uint16_t srcport, uint16_t dstport)
2299 struct vxlanudphdr *hdr;
2300 struct udphdr *udph;
2301 struct vxlan_header *vxh;
2304 len = m->m_pkthdr.len - ipoff;
2305 MPASS(len >= sizeof(struct vxlanudphdr));
2306 hdr = mtodo(m, ipoff);
2308 udph = &hdr->vxlh_udp;
2309 udph->uh_sport = srcport;
2310 udph->uh_dport = dstport;
2311 udph->uh_ulen = htons(len);
2314 vxh = &hdr->vxlh_hdr;
2315 vxh->vxlh_flags = htonl(VXLAN_HDR_FLAGS_VALID_VNI);
2316 vxh->vxlh_vni = htonl(sc->vxl_vni << VXLAN_HDR_VNI_SHIFT);
2321 vxlan_encap4(struct vxlan_softc *sc, const union vxlan_sockaddr *fvxlsa,
2327 struct in_addr srcaddr, dstaddr;
2328 uint16_t srcport, dstport;
2329 int len, mcast, error;
2332 srcaddr = sc->vxl_src_addr.in4.sin_addr;
2333 srcport = vxlan_pick_source_port(sc, m);
2334 dstaddr = fvxlsa->in4.sin_addr;
2335 dstport = fvxlsa->in4.sin_port;
2337 M_PREPEND(m, sizeof(struct ip) + sizeof(struct vxlanudphdr),
2340 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2344 len = m->m_pkthdr.len;
2346 ip = mtod(m, struct ip *);
2348 ip->ip_len = htons(len);
2350 ip->ip_ttl = sc->vxl_ttl;
2351 ip->ip_p = IPPROTO_UDP;
2353 ip->ip_src = srcaddr;
2354 ip->ip_dst = dstaddr;
2356 vxlan_encap_header(sc, m, sizeof(struct ip), srcport, dstport);
2358 mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0;
2359 m->m_flags &= ~(M_MCAST | M_BCAST);
2361 error = ip_output(m, NULL, NULL, 0, sc->vxl_im4o, NULL);
2363 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2364 if_inc_counter(ifp, IFCOUNTER_OBYTES, len);
2366 if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
2368 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2378 vxlan_encap6(struct vxlan_softc *sc, const union vxlan_sockaddr *fvxlsa,
2383 struct ip6_hdr *ip6;
2384 const struct in6_addr *srcaddr, *dstaddr;
2385 uint16_t srcport, dstport;
2386 int len, mcast, error;
2389 srcaddr = &sc->vxl_src_addr.in6.sin6_addr;
2390 srcport = vxlan_pick_source_port(sc, m);
2391 dstaddr = &fvxlsa->in6.sin6_addr;
2392 dstport = fvxlsa->in6.sin6_port;
2394 M_PREPEND(m, sizeof(struct ip6_hdr) + sizeof(struct vxlanudphdr),
2397 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2401 len = m->m_pkthdr.len;
2403 ip6 = mtod(m, struct ip6_hdr *);
2404 ip6->ip6_flow = 0; /* BMV: Keep in forwarding entry? */
2405 ip6->ip6_vfc = IPV6_VERSION;
2407 ip6->ip6_nxt = IPPROTO_UDP;
2408 ip6->ip6_hlim = sc->vxl_ttl;
2409 ip6->ip6_src = *srcaddr;
2410 ip6->ip6_dst = *dstaddr;
2412 vxlan_encap_header(sc, m, sizeof(struct ip6_hdr), srcport, dstport);
2415 * XXX BMV We need support for RFC6935 before we can send and
2416 * receive IPv6 UDP packets with a zero checksum.
2419 struct udphdr *hdr = mtodo(m, sizeof(struct ip6_hdr));
2420 hdr->uh_sum = in6_cksum_pseudo(ip6,
2421 m->m_pkthdr.len - sizeof(struct ip6_hdr), IPPROTO_UDP, 0);
2422 m->m_pkthdr.csum_flags = CSUM_UDP_IPV6;
2423 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
2426 mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0;
2427 m->m_flags &= ~(M_MCAST | M_BCAST);
2429 error = ip6_output(m, NULL, NULL, 0, sc->vxl_im6o, NULL, NULL);
2431 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2432 if_inc_counter(ifp, IFCOUNTER_OBYTES, len);
2434 if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
2436 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2446 vxlan_transmit(struct ifnet *ifp, struct mbuf *m)
2448 struct rm_priotracker tracker;
2449 union vxlan_sockaddr vxlsa;
2450 struct vxlan_softc *sc;
2451 struct vxlan_ftable_entry *fe;
2452 struct ifnet *mcifp;
2453 struct ether_header *eh;
2457 eh = mtod(m, struct ether_header *);
2461 ETHER_BPF_MTAP(ifp, m);
2463 VXLAN_RLOCK(sc, &tracker);
2464 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
2465 VXLAN_RUNLOCK(sc, &tracker);
2470 if ((m->m_flags & (M_BCAST | M_MCAST)) == 0)
2471 fe = vxlan_ftable_entry_lookup(sc, eh->ether_dhost);
2473 fe = &sc->vxl_default_fe;
2474 vxlan_sockaddr_copy(&vxlsa, &fe->vxlfe_raddr.sa);
2476 ipv4 = VXLAN_SOCKADDR_IS_IPV4(&vxlsa) != 0;
2477 if (vxlan_sockaddr_in_multicast(&vxlsa) != 0)
2478 mcifp = vxlan_multicast_if_ref(sc, ipv4);
2481 VXLAN_RUNLOCK(sc, &tracker);
2484 error = vxlan_encap4(sc, &vxlsa, m);
2486 error = vxlan_encap6(sc, &vxlsa, m);
2496 vxlan_qflush(struct ifnet *ifp __unused)
2501 vxlan_rcv_udp_packet(struct mbuf *m, int offset, struct inpcb *inpcb,
2502 const struct sockaddr *srcsa, void *xvso)
2504 struct vxlan_socket *vso;
2505 struct vxlan_header *vxh, vxlanhdr;
2511 offset += sizeof(struct udphdr);
2513 if (m->m_pkthdr.len < offset + sizeof(struct vxlan_header))
2516 if (__predict_false(m->m_len < offset + sizeof(struct vxlan_header))) {
2517 m_copydata(m, offset, sizeof(struct vxlan_header),
2518 (caddr_t) &vxlanhdr);
2521 vxh = mtodo(m, offset);
2524 * Drop if there is a reserved bit set in either the flags or VNI
2525 * fields of the header. This goes against the specification, but
2526 * a bit set may indicate an unsupported new feature. This matches
2527 * the behavior of the Linux implementation.
2529 if (vxh->vxlh_flags != htonl(VXLAN_HDR_FLAGS_VALID_VNI) ||
2530 vxh->vxlh_vni & ~htonl(VXLAN_VNI_MASK))
2533 vni = ntohl(vxh->vxlh_vni) >> VXLAN_HDR_VNI_SHIFT;
2534 /* Adjust to the start of the inner Ethernet frame. */
2535 m_adj(m, offset + sizeof(struct vxlan_header));
2537 error = vxlan_input(vso, vni, &m, srcsa);
2538 MPASS(error != 0 || m == NULL);
2546 vxlan_input(struct vxlan_socket *vso, uint32_t vni, struct mbuf **m0,
2547 const struct sockaddr *sa)
2549 struct vxlan_softc *sc;
2552 struct ether_header *eh;
2555 sc = vxlan_socket_lookup_softc(vso, vni);
2561 eh = mtod(m, struct ether_header *);
2563 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
2566 } else if (ifp == m->m_pkthdr.rcvif) {
2567 /* XXX Does not catch more complex loops. */
2572 if (sc->vxl_flags & VXLAN_FLAG_LEARN)
2573 vxlan_ftable_learn(sc, sa, eh->ether_shost);
2576 m->m_pkthdr.rcvif = ifp;
2577 M_SETFIB(m, ifp->if_fib);
2579 error = netisr_queue_src(NETISR_ETHER, 0, m);
2588 vxlan_set_default_config(struct vxlan_softc *sc)
2591 sc->vxl_flags |= VXLAN_FLAG_LEARN;
2593 sc->vxl_vni = VXLAN_VNI_MAX;
2594 sc->vxl_ttl = IPDEFTTL;
2596 if (!vxlan_tunable_int(sc, "legacy_port", vxlan_legacy_port)) {
2597 sc->vxl_src_addr.in4.sin_port = htons(VXLAN_PORT);
2598 sc->vxl_dst_addr.in4.sin_port = htons(VXLAN_PORT);
2600 sc->vxl_src_addr.in4.sin_port = htons(VXLAN_LEGACY_PORT);
2601 sc->vxl_dst_addr.in4.sin_port = htons(VXLAN_LEGACY_PORT);
2604 sc->vxl_min_port = V_ipport_firstauto;
2605 sc->vxl_max_port = V_ipport_lastauto;
2607 sc->vxl_ftable_max = VXLAN_FTABLE_MAX;
2608 sc->vxl_ftable_timeout = VXLAN_FTABLE_TIMEOUT;
2612 vxlan_set_user_config(struct vxlan_softc *sc, struct ifvxlanparam *vxlp)
2616 if (vxlp->vxlp_with & (VXLAN_PARAM_WITH_LOCAL_ADDR4 |
2617 VXLAN_PARAM_WITH_REMOTE_ADDR4))
2618 return (EAFNOSUPPORT);
2622 if (vxlp->vxlp_with & (VXLAN_PARAM_WITH_LOCAL_ADDR6 |
2623 VXLAN_PARAM_WITH_REMOTE_ADDR6))
2624 return (EAFNOSUPPORT);
2626 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR6) {
2627 int error = vxlan_sockaddr_in6_embedscope(&vxlp->vxlp_local_sa);
2631 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR6) {
2632 int error = vxlan_sockaddr_in6_embedscope(
2633 &vxlp->vxlp_remote_sa);
2639 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_VNI) {
2640 if (vxlan_check_vni(vxlp->vxlp_vni) == 0)
2641 sc->vxl_vni = vxlp->vxlp_vni;
2644 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR4) {
2645 sc->vxl_src_addr.in4.sin_len = sizeof(struct sockaddr_in);
2646 sc->vxl_src_addr.in4.sin_family = AF_INET;
2647 sc->vxl_src_addr.in4.sin_addr =
2648 vxlp->vxlp_local_sa.in4.sin_addr;
2649 } else if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR6) {
2650 sc->vxl_src_addr.in6.sin6_len = sizeof(struct sockaddr_in6);
2651 sc->vxl_src_addr.in6.sin6_family = AF_INET6;
2652 sc->vxl_src_addr.in6.sin6_addr =
2653 vxlp->vxlp_local_sa.in6.sin6_addr;
2656 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR4) {
2657 sc->vxl_dst_addr.in4.sin_len = sizeof(struct sockaddr_in);
2658 sc->vxl_dst_addr.in4.sin_family = AF_INET;
2659 sc->vxl_dst_addr.in4.sin_addr =
2660 vxlp->vxlp_remote_sa.in4.sin_addr;
2661 } else if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR6) {
2662 sc->vxl_dst_addr.in6.sin6_len = sizeof(struct sockaddr_in6);
2663 sc->vxl_dst_addr.in6.sin6_family = AF_INET6;
2664 sc->vxl_dst_addr.in6.sin6_addr =
2665 vxlp->vxlp_remote_sa.in6.sin6_addr;
2668 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_PORT)
2669 sc->vxl_src_addr.in4.sin_port = htons(vxlp->vxlp_local_port);
2670 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_PORT)
2671 sc->vxl_dst_addr.in4.sin_port = htons(vxlp->vxlp_remote_port);
2673 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_PORT_RANGE) {
2674 if (vxlp->vxlp_min_port <= vxlp->vxlp_max_port) {
2675 sc->vxl_min_port = vxlp->vxlp_min_port;
2676 sc->vxl_max_port = vxlp->vxlp_max_port;
2680 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_MULTICAST_IF)
2681 strlcpy(sc->vxl_mc_ifname, vxlp->vxlp_mc_ifname, IFNAMSIZ);
2683 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_FTABLE_TIMEOUT) {
2684 if (vxlan_check_ftable_timeout(vxlp->vxlp_ftable_timeout) == 0)
2685 sc->vxl_ftable_timeout = vxlp->vxlp_ftable_timeout;
2688 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_FTABLE_MAX) {
2689 if (vxlan_check_ftable_max(vxlp->vxlp_ftable_max) == 0)
2690 sc->vxl_ftable_max = vxlp->vxlp_ftable_max;
2693 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_TTL) {
2694 if (vxlan_check_ttl(vxlp->vxlp_ttl) == 0)
2695 sc->vxl_ttl = vxlp->vxlp_ttl;
2698 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LEARN) {
2699 if (vxlp->vxlp_learn == 0)
2700 sc->vxl_flags &= ~VXLAN_FLAG_LEARN;
2707 vxlan_clone_create(struct if_clone *ifc, int unit, caddr_t params)
2709 struct vxlan_softc *sc;
2711 struct ifvxlanparam vxlp;
2714 sc = malloc(sizeof(struct vxlan_softc), M_VXLAN, M_WAITOK | M_ZERO);
2715 sc->vxl_unit = unit;
2716 vxlan_set_default_config(sc);
2719 error = copyin(params, &vxlp, sizeof(vxlp));
2723 error = vxlan_set_user_config(sc, &vxlp);
2728 ifp = if_alloc(IFT_ETHER);
2735 rm_init(&sc->vxl_lock, "vxlanrm");
2736 callout_init_rw(&sc->vxl_callout, &sc->vxl_lock, 0);
2737 sc->vxl_port_hash_key = arc4random();
2738 vxlan_ftable_init(sc);
2740 vxlan_sysctl_setup(sc);
2743 if_initname(ifp, vxlan_name, unit);
2744 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
2745 ifp->if_init = vxlan_init;
2746 ifp->if_ioctl = vxlan_ioctl;
2747 ifp->if_transmit = vxlan_transmit;
2748 ifp->if_qflush = vxlan_qflush;
2749 ifp->if_capabilities |= IFCAP_LINKSTATE;
2750 ifp->if_capenable |= IFCAP_LINKSTATE;
2752 ifmedia_init(&sc->vxl_media, 0, vxlan_media_change, vxlan_media_status);
2753 ifmedia_add(&sc->vxl_media, IFM_ETHER | IFM_AUTO, 0, NULL);
2754 ifmedia_set(&sc->vxl_media, IFM_ETHER | IFM_AUTO);
2756 ether_gen_addr(ifp, &sc->vxl_hwaddr);
2757 ether_ifattach(ifp, sc->vxl_hwaddr.octet);
2759 ifp->if_baudrate = 0;
2770 vxlan_clone_destroy(struct ifnet *ifp)
2772 struct vxlan_softc *sc;
2778 vxlan_ftable_flush(sc, 1);
2780 ether_ifdetach(ifp);
2782 ifmedia_removeall(&sc->vxl_media);
2784 vxlan_ftable_fini(sc);
2786 vxlan_sysctl_destroy(sc);
2787 rm_destroy(&sc->vxl_lock);
2791 /* BMV: Taken from if_bridge. */
2793 vxlan_mac_hash(struct vxlan_softc *sc, const uint8_t *addr)
2795 uint32_t a = 0x9e3779b9, b = 0x9e3779b9, c = sc->vxl_ftable_hash_key;
2805 * The following hash function is adapted from "Hash Functions" by Bob Jenkins
2806 * ("Algorithm Alley", Dr. Dobbs Journal, September 1997).
2808 #define mix(a, b, c) \
2810 a -= b; a -= c; a ^= (c >> 13); \
2811 b -= c; b -= a; b ^= (a << 8); \
2812 c -= a; c -= b; c ^= (b >> 13); \
2813 a -= b; a -= c; a ^= (c >> 12); \
2814 b -= c; b -= a; b ^= (a << 16); \
2815 c -= a; c -= b; c ^= (b >> 5); \
2816 a -= b; a -= c; a ^= (c >> 3); \
2817 b -= c; b -= a; b ^= (a << 10); \
2818 c -= a; c -= b; c ^= (b >> 15); \
2829 vxlan_media_change(struct ifnet *ifp)
2837 vxlan_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
2840 ifmr->ifm_status = IFM_ACTIVE | IFM_AVALID;
2841 ifmr->ifm_active = IFM_ETHER | IFM_FDX;
2845 vxlan_sockaddr_cmp(const union vxlan_sockaddr *vxladdr,
2846 const struct sockaddr *sa)
2849 return (bcmp(&vxladdr->sa, sa, vxladdr->sa.sa_len));
2853 vxlan_sockaddr_copy(union vxlan_sockaddr *vxladdr,
2854 const struct sockaddr *sa)
2857 MPASS(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
2858 bzero(vxladdr, sizeof(*vxladdr));
2860 if (sa->sa_family == AF_INET) {
2861 vxladdr->in4 = *satoconstsin(sa);
2862 vxladdr->in4.sin_len = sizeof(struct sockaddr_in);
2863 } else if (sa->sa_family == AF_INET6) {
2864 vxladdr->in6 = *satoconstsin6(sa);
2865 vxladdr->in6.sin6_len = sizeof(struct sockaddr_in6);
2870 vxlan_sockaddr_in_equal(const union vxlan_sockaddr *vxladdr,
2871 const struct sockaddr *sa)
2875 if (sa->sa_family == AF_INET) {
2876 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2877 equal = in4->s_addr == vxladdr->in4.sin_addr.s_addr;
2878 } else if (sa->sa_family == AF_INET6) {
2879 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2880 equal = IN6_ARE_ADDR_EQUAL(in6, &vxladdr->in6.sin6_addr);
2888 vxlan_sockaddr_in_copy(union vxlan_sockaddr *vxladdr,
2889 const struct sockaddr *sa)
2892 MPASS(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
2894 if (sa->sa_family == AF_INET) {
2895 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2896 vxladdr->in4.sin_family = AF_INET;
2897 vxladdr->in4.sin_len = sizeof(struct sockaddr_in);
2898 vxladdr->in4.sin_addr = *in4;
2899 } else if (sa->sa_family == AF_INET6) {
2900 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2901 vxladdr->in6.sin6_family = AF_INET6;
2902 vxladdr->in6.sin6_len = sizeof(struct sockaddr_in6);
2903 vxladdr->in6.sin6_addr = *in6;
2908 vxlan_sockaddr_supported(const union vxlan_sockaddr *vxladdr, int unspec)
2910 const struct sockaddr *sa;
2916 if (sa->sa_family == AF_UNSPEC && unspec != 0) {
2918 } else if (sa->sa_family == AF_INET) {
2922 } else if (sa->sa_family == AF_INET6) {
2932 vxlan_sockaddr_in_any(const union vxlan_sockaddr *vxladdr)
2934 const struct sockaddr *sa;
2939 if (sa->sa_family == AF_INET) {
2940 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2941 any = in4->s_addr == INADDR_ANY;
2942 } else if (sa->sa_family == AF_INET6) {
2943 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2944 any = IN6_IS_ADDR_UNSPECIFIED(in6);
2952 vxlan_sockaddr_in_multicast(const union vxlan_sockaddr *vxladdr)
2954 const struct sockaddr *sa;
2959 if (sa->sa_family == AF_INET) {
2960 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2961 mc = IN_MULTICAST(ntohl(in4->s_addr));
2962 } else if (sa->sa_family == AF_INET6) {
2963 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2964 mc = IN6_IS_ADDR_MULTICAST(in6);
2972 vxlan_sockaddr_in6_embedscope(union vxlan_sockaddr *vxladdr)
2976 MPASS(VXLAN_SOCKADDR_IS_IPV6(vxladdr));
2978 error = sa6_embedscope(&vxladdr->in6, V_ip6_use_defzone);
2980 error = EAFNOSUPPORT;
2987 vxlan_can_change_config(struct vxlan_softc *sc)
2992 VXLAN_LOCK_ASSERT(sc);
2994 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
2996 if (sc->vxl_flags & (VXLAN_FLAG_INIT | VXLAN_FLAG_TEARDOWN))
3003 vxlan_check_vni(uint32_t vni)
3006 return (vni >= VXLAN_VNI_MAX);
3010 vxlan_check_ttl(int ttl)
3013 return (ttl > MAXTTL);
3017 vxlan_check_ftable_timeout(uint32_t timeout)
3020 return (timeout > VXLAN_FTABLE_MAX_TIMEOUT);
3024 vxlan_check_ftable_max(uint32_t max)
3027 return (max > VXLAN_FTABLE_MAX);
3031 vxlan_sysctl_setup(struct vxlan_softc *sc)
3033 struct sysctl_ctx_list *ctx;
3034 struct sysctl_oid *node;
3035 struct vxlan_statistics *stats;
3038 ctx = &sc->vxl_sysctl_ctx;
3039 stats = &sc->vxl_stats;
3040 snprintf(namebuf, sizeof(namebuf), "%d", sc->vxl_unit);
3042 sysctl_ctx_init(ctx);
3043 sc->vxl_sysctl_node = SYSCTL_ADD_NODE(ctx,
3044 SYSCTL_STATIC_CHILDREN(_net_link_vxlan), OID_AUTO, namebuf,
3045 CTLFLAG_RD, NULL, "");
3047 node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sc->vxl_sysctl_node),
3048 OID_AUTO, "ftable", CTLFLAG_RD, NULL, "");
3049 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "count",
3050 CTLFLAG_RD, &sc->vxl_ftable_cnt, 0,
3051 "Number of entries in fowarding table");
3052 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "max",
3053 CTLFLAG_RD, &sc->vxl_ftable_max, 0,
3054 "Maximum number of entries allowed in fowarding table");
3055 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "timeout",
3056 CTLFLAG_RD, &sc->vxl_ftable_timeout, 0,
3057 "Number of seconds between prunes of the forwarding table");
3058 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "dump",
3059 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_SKIP,
3060 sc, 0, vxlan_ftable_sysctl_dump, "A",
3061 "Dump the forwarding table entries");
3063 node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sc->vxl_sysctl_node),
3064 OID_AUTO, "stats", CTLFLAG_RD, NULL, "");
3065 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
3066 "ftable_nospace", CTLFLAG_RD, &stats->ftable_nospace, 0,
3067 "Fowarding table reached maximum entries");
3068 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
3069 "ftable_lock_upgrade_failed", CTLFLAG_RD,
3070 &stats->ftable_lock_upgrade_failed, 0,
3071 "Forwarding table update required lock upgrade");
3075 vxlan_sysctl_destroy(struct vxlan_softc *sc)
3078 sysctl_ctx_free(&sc->vxl_sysctl_ctx);
3079 sc->vxl_sysctl_node = NULL;
3083 vxlan_tunable_int(struct vxlan_softc *sc, const char *knob, int def)
3087 snprintf(path, sizeof(path), "net.link.vxlan.%d.%s",
3088 sc->vxl_unit, knob);
3089 TUNABLE_INT_FETCH(path, &def);
3095 vxlan_ifdetach_event(void *arg __unused, struct ifnet *ifp)
3097 struct vxlan_softc_head list;
3098 struct vxlan_socket *vso;
3099 struct vxlan_softc *sc, *tsc;
3103 if (ifp->if_flags & IFF_RENAMING)
3105 if ((ifp->if_flags & IFF_MULTICAST) == 0)
3109 LIST_FOREACH(vso, &vxlan_socket_list, vxlso_entry)
3110 vxlan_socket_ifdetach(vso, ifp, &list);
3111 VXLAN_LIST_UNLOCK();
3113 LIST_FOREACH_SAFE(sc, &list, vxl_ifdetach_list, tsc) {
3114 LIST_REMOVE(sc, vxl_ifdetach_list);
3117 if (sc->vxl_flags & VXLAN_FLAG_INIT)
3118 vxlan_init_wait(sc);
3119 vxlan_teardown_locked(sc);
3127 mtx_init(&vxlan_list_mtx, "vxlan list", NULL, MTX_DEF);
3128 LIST_INIT(&vxlan_socket_list);
3129 vxlan_ifdetach_event_tag = EVENTHANDLER_REGISTER(ifnet_departure_event,
3130 vxlan_ifdetach_event, NULL, EVENTHANDLER_PRI_ANY);
3131 vxlan_cloner = if_clone_simple(vxlan_name, vxlan_clone_create,
3132 vxlan_clone_destroy, 0);
3139 EVENTHANDLER_DEREGISTER(ifnet_departure_event,
3140 vxlan_ifdetach_event_tag);
3141 if_clone_detach(vxlan_cloner);
3142 mtx_destroy(&vxlan_list_mtx);
3143 MPASS(LIST_EMPTY(&vxlan_socket_list));
3147 vxlan_modevent(module_t mod, int type, void *unused)
3168 static moduledata_t vxlan_mod = {
3174 DECLARE_MODULE(if_vxlan, vxlan_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
3175 MODULE_VERSION(if_vxlan, 1);