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)
867 struct vxlan_socket_mc_info *mc;
869 for (i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
870 mc = &vso->vxlso_mc[i];
871 KASSERT(mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC,
872 ("%s: socket %p mc[%d] still has address",
876 for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++) {
877 KASSERT(LIST_EMPTY(&vso->vxlso_vni_hash[i]),
878 ("%s: socket %p vni_hash[%d] not empty",
882 so = vso->vxlso_sock;
884 vso->vxlso_sock = NULL;
888 rm_destroy(&vso->vxlso_lock);
893 vxlan_socket_release(struct vxlan_socket *vso)
898 destroy = VXLAN_SO_RELEASE(vso);
900 LIST_REMOVE(vso, vxlso_entry);
904 vxlan_socket_destroy(vso);
907 static struct vxlan_socket *
908 vxlan_socket_lookup(union vxlan_sockaddr *vxlsa)
910 struct vxlan_socket *vso;
913 LIST_FOREACH(vso, &vxlan_socket_list, vxlso_entry) {
914 if (vxlan_sockaddr_cmp(&vso->vxlso_laddr, &vxlsa->sa) == 0) {
915 VXLAN_SO_ACQUIRE(vso);
925 vxlan_socket_insert(struct vxlan_socket *vso)
929 VXLAN_SO_ACQUIRE(vso);
930 LIST_INSERT_HEAD(&vxlan_socket_list, vso, vxlso_entry);
935 vxlan_socket_init(struct vxlan_socket *vso, struct ifnet *ifp)
942 error = socreate(vso->vxlso_laddr.sa.sa_family, &vso->vxlso_sock,
943 SOCK_DGRAM, IPPROTO_UDP, td->td_ucred, td);
945 if_printf(ifp, "cannot create socket: %d\n", error);
949 error = udp_set_kernel_tunneling(vso->vxlso_sock,
950 vxlan_rcv_udp_packet, NULL, vso);
952 if_printf(ifp, "cannot set tunneling function: %d\n", error);
956 if (vxlan_reuse_port != 0) {
960 bzero(&sopt, sizeof(sopt));
961 sopt.sopt_dir = SOPT_SET;
962 sopt.sopt_level = IPPROTO_IP;
963 sopt.sopt_name = SO_REUSEPORT;
964 sopt.sopt_val = &val;
965 sopt.sopt_valsize = sizeof(val);
966 error = sosetopt(vso->vxlso_sock, &sopt);
969 "cannot set REUSEADDR socket opt: %d\n", error);
978 vxlan_socket_bind(struct vxlan_socket *vso, struct ifnet *ifp)
980 union vxlan_sockaddr laddr;
985 laddr = vso->vxlso_laddr;
987 error = sobind(vso->vxlso_sock, &laddr.sa, td);
989 if (error != EADDRINUSE)
990 if_printf(ifp, "cannot bind socket: %d\n", error);
998 vxlan_socket_create(struct ifnet *ifp, int multicast,
999 const union vxlan_sockaddr *saddr, struct vxlan_socket **vsop)
1001 union vxlan_sockaddr laddr;
1002 struct vxlan_socket *vso;
1008 * If this socket will be multicast, then only the local port
1009 * must be specified when binding.
1011 if (multicast != 0) {
1012 if (VXLAN_SOCKADDR_IS_IPV4(&laddr))
1013 laddr.in4.sin_addr.s_addr = INADDR_ANY;
1016 laddr.in6.sin6_addr = in6addr_any;
1020 vso = vxlan_socket_alloc(&laddr);
1024 error = vxlan_socket_init(vso, ifp);
1028 error = vxlan_socket_bind(vso, ifp);
1033 * There is a small window between the bind completing and
1034 * inserting the socket, so that a concurrent create may fail.
1035 * Let's not worry about that for now.
1037 vxlan_socket_insert(vso);
1043 vxlan_socket_destroy(vso);
1049 vxlan_socket_ifdetach(struct vxlan_socket *vso, struct ifnet *ifp,
1050 struct vxlan_softc_head *list)
1052 struct rm_priotracker tracker;
1053 struct vxlan_softc *sc;
1056 VXLAN_SO_RLOCK(vso, &tracker);
1057 for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++) {
1058 LIST_FOREACH(sc, &vso->vxlso_vni_hash[i], vxl_entry)
1059 vxlan_ifdetach(sc, ifp, list);
1061 VXLAN_SO_RUNLOCK(vso, &tracker);
1064 static struct vxlan_socket *
1065 vxlan_socket_mc_lookup(const union vxlan_sockaddr *vxlsa)
1067 union vxlan_sockaddr laddr;
1068 struct vxlan_socket *vso;
1072 if (VXLAN_SOCKADDR_IS_IPV4(&laddr))
1073 laddr.in4.sin_addr.s_addr = INADDR_ANY;
1076 laddr.in6.sin6_addr = in6addr_any;
1079 vso = vxlan_socket_lookup(&laddr);
1085 vxlan_sockaddr_mc_info_match(const struct vxlan_socket_mc_info *mc,
1086 const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1090 if (!vxlan_sockaddr_in_any(local) &&
1091 !vxlan_sockaddr_in_equal(&mc->vxlsomc_saddr, &local->sa))
1093 if (!vxlan_sockaddr_in_equal(&mc->vxlsomc_gaddr, &group->sa))
1095 if (ifidx != 0 && ifidx != mc->vxlsomc_ifidx)
1102 vxlan_socket_mc_join_group(struct vxlan_socket *vso,
1103 const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1104 int *ifidx, union vxlan_sockaddr *source)
1106 struct sockopt sopt;
1111 if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1112 struct ip_mreq mreq;
1114 mreq.imr_multiaddr = group->in4.sin_addr;
1115 mreq.imr_interface = local->in4.sin_addr;
1117 bzero(&sopt, sizeof(sopt));
1118 sopt.sopt_dir = SOPT_SET;
1119 sopt.sopt_level = IPPROTO_IP;
1120 sopt.sopt_name = IP_ADD_MEMBERSHIP;
1121 sopt.sopt_val = &mreq;
1122 sopt.sopt_valsize = sizeof(mreq);
1123 error = sosetopt(vso->vxlso_sock, &sopt);
1128 * BMV: Ideally, there would be a formal way for us to get
1129 * the local interface that was selected based on the
1130 * imr_interface address. We could then update *ifidx so
1131 * vxlan_sockaddr_mc_info_match() would return a match for
1132 * later creates that explicitly set the multicast interface.
1134 * If we really need to, we can of course look in the INP's
1136 * sotoinpcb(vso->vxlso_sock)->inp_moptions->
1137 * imo_head[]->imf_inm->inm_ifp
1138 * similarly to imo_match_group().
1140 source->in4.sin_addr = local->in4.sin_addr;
1142 } else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1143 struct ipv6_mreq mreq;
1145 mreq.ipv6mr_multiaddr = group->in6.sin6_addr;
1146 mreq.ipv6mr_interface = *ifidx;
1148 bzero(&sopt, sizeof(sopt));
1149 sopt.sopt_dir = SOPT_SET;
1150 sopt.sopt_level = IPPROTO_IPV6;
1151 sopt.sopt_name = IPV6_JOIN_GROUP;
1152 sopt.sopt_val = &mreq;
1153 sopt.sopt_valsize = sizeof(mreq);
1154 error = sosetopt(vso->vxlso_sock, &sopt);
1159 * BMV: As with IPv4, we would really like to know what
1160 * interface in6p_lookup_mcast_ifp() selected.
1163 error = EAFNOSUPPORT;
1169 vxlan_socket_mc_leave_group(struct vxlan_socket *vso,
1170 const union vxlan_sockaddr *group, const union vxlan_sockaddr *source,
1173 struct sockopt sopt;
1176 bzero(&sopt, sizeof(sopt));
1177 sopt.sopt_dir = SOPT_SET;
1179 if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1180 struct ip_mreq mreq;
1182 mreq.imr_multiaddr = group->in4.sin_addr;
1183 mreq.imr_interface = source->in4.sin_addr;
1185 sopt.sopt_level = IPPROTO_IP;
1186 sopt.sopt_name = IP_DROP_MEMBERSHIP;
1187 sopt.sopt_val = &mreq;
1188 sopt.sopt_valsize = sizeof(mreq);
1189 error = sosetopt(vso->vxlso_sock, &sopt);
1191 } else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1192 struct ipv6_mreq mreq;
1194 mreq.ipv6mr_multiaddr = group->in6.sin6_addr;
1195 mreq.ipv6mr_interface = ifidx;
1197 sopt.sopt_level = IPPROTO_IPV6;
1198 sopt.sopt_name = IPV6_LEAVE_GROUP;
1199 sopt.sopt_val = &mreq;
1200 sopt.sopt_valsize = sizeof(mreq);
1201 error = sosetopt(vso->vxlso_sock, &sopt);
1204 error = EAFNOSUPPORT;
1210 vxlan_socket_mc_add_group(struct vxlan_socket *vso,
1211 const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1212 int ifidx, int *idx)
1214 union vxlan_sockaddr source;
1215 struct vxlan_socket_mc_info *mc;
1216 int i, empty, error;
1219 * Within a socket, the same multicast group may be used by multiple
1220 * interfaces, each with a different network identifier. But a socket
1221 * may only join a multicast group once, so keep track of the users
1225 VXLAN_SO_WLOCK(vso);
1226 for (empty = 0, i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
1227 mc = &vso->vxlso_mc[i];
1229 if (mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC) {
1234 if (vxlan_sockaddr_mc_info_match(mc, group, local, ifidx))
1237 VXLAN_SO_WUNLOCK(vso);
1242 error = vxlan_socket_mc_join_group(vso, group, local, &ifidx, &source);
1246 VXLAN_SO_WLOCK(vso);
1247 for (i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
1248 mc = &vso->vxlso_mc[i];
1250 if (mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC) {
1251 vxlan_sockaddr_copy(&mc->vxlsomc_gaddr, &group->sa);
1252 vxlan_sockaddr_copy(&mc->vxlsomc_saddr, &source.sa);
1253 mc->vxlsomc_ifidx = ifidx;
1257 VXLAN_SO_WUNLOCK(vso);
1259 error = vxlan_socket_mc_leave_group(vso, group, &source, ifidx);
1265 mc->vxlsomc_users++;
1266 VXLAN_SO_WUNLOCK(vso);
1274 vxlan_socket_mc_release_group_by_idx(struct vxlan_socket *vso, int idx)
1276 union vxlan_sockaddr group, source;
1277 struct vxlan_socket_mc_info *mc;
1280 KASSERT(idx >= 0 && idx < VXLAN_SO_MC_MAX_GROUPS,
1281 ("%s: vso %p idx %d out of bounds", __func__, vso, idx));
1284 mc = &vso->vxlso_mc[idx];
1286 VXLAN_SO_WLOCK(vso);
1287 mc->vxlsomc_users--;
1288 if (mc->vxlsomc_users == 0) {
1289 group = mc->vxlsomc_gaddr;
1290 source = mc->vxlsomc_saddr;
1291 ifidx = mc->vxlsomc_ifidx;
1292 bzero(mc, sizeof(*mc));
1295 VXLAN_SO_WUNLOCK(vso);
1299 * Our socket's membership in this group may have already
1300 * been removed if we joined through an interface that's
1303 vxlan_socket_mc_leave_group(vso, &group, &source, ifidx);
1307 static struct vxlan_softc *
1308 vxlan_socket_lookup_softc_locked(struct vxlan_socket *vso, uint32_t vni)
1310 struct vxlan_softc *sc;
1313 VXLAN_SO_LOCK_ASSERT(vso);
1314 hash = VXLAN_SO_VNI_HASH(vni);
1316 LIST_FOREACH(sc, &vso->vxlso_vni_hash[hash], vxl_entry) {
1317 if (sc->vxl_vni == vni) {
1326 static struct vxlan_softc *
1327 vxlan_socket_lookup_softc(struct vxlan_socket *vso, uint32_t vni)
1329 struct rm_priotracker tracker;
1330 struct vxlan_softc *sc;
1332 VXLAN_SO_RLOCK(vso, &tracker);
1333 sc = vxlan_socket_lookup_softc_locked(vso, vni);
1334 VXLAN_SO_RUNLOCK(vso, &tracker);
1340 vxlan_socket_insert_softc(struct vxlan_socket *vso, struct vxlan_softc *sc)
1342 struct vxlan_softc *tsc;
1346 hash = VXLAN_SO_VNI_HASH(vni);
1348 VXLAN_SO_WLOCK(vso);
1349 tsc = vxlan_socket_lookup_softc_locked(vso, vni);
1351 VXLAN_SO_WUNLOCK(vso);
1357 LIST_INSERT_HEAD(&vso->vxlso_vni_hash[hash], sc, vxl_entry);
1358 VXLAN_SO_WUNLOCK(vso);
1364 vxlan_socket_remove_softc(struct vxlan_socket *vso, struct vxlan_softc *sc)
1367 VXLAN_SO_WLOCK(vso);
1368 LIST_REMOVE(sc, vxl_entry);
1369 VXLAN_SO_WUNLOCK(vso);
1374 static struct ifnet *
1375 vxlan_multicast_if_ref(struct vxlan_softc *sc, int ipv4)
1379 VXLAN_LOCK_ASSERT(sc);
1381 if (ipv4 && sc->vxl_im4o != NULL)
1382 ifp = sc->vxl_im4o->imo_multicast_ifp;
1383 else if (!ipv4 && sc->vxl_im6o != NULL)
1384 ifp = sc->vxl_im6o->im6o_multicast_ifp;
1395 vxlan_free_multicast(struct vxlan_softc *sc)
1398 if (sc->vxl_mc_ifp != NULL) {
1399 if_rele(sc->vxl_mc_ifp);
1400 sc->vxl_mc_ifp = NULL;
1401 sc->vxl_mc_ifindex = 0;
1404 if (sc->vxl_im4o != NULL) {
1405 free(sc->vxl_im4o, M_VXLAN);
1406 sc->vxl_im4o = NULL;
1409 if (sc->vxl_im6o != NULL) {
1410 free(sc->vxl_im6o, M_VXLAN);
1411 sc->vxl_im6o = NULL;
1416 vxlan_setup_multicast_interface(struct vxlan_softc *sc)
1420 ifp = ifunit_ref(sc->vxl_mc_ifname);
1422 if_printf(sc->vxl_ifp, "multicast interface %s does "
1423 "not exist\n", sc->vxl_mc_ifname);
1427 if ((ifp->if_flags & IFF_MULTICAST) == 0) {
1428 if_printf(sc->vxl_ifp, "interface %s does not support "
1429 "multicast\n", sc->vxl_mc_ifname);
1434 sc->vxl_mc_ifp = ifp;
1435 sc->vxl_mc_ifindex = ifp->if_index;
1441 vxlan_setup_multicast(struct vxlan_softc *sc)
1443 const union vxlan_sockaddr *group;
1446 group = &sc->vxl_dst_addr;
1449 if (sc->vxl_mc_ifname[0] != '\0') {
1450 error = vxlan_setup_multicast_interface(sc);
1456 * Initialize an multicast options structure that is sufficiently
1457 * populated for use in the respective IP output routine. This
1458 * structure is typically stored in the socket, but our sockets
1459 * may be shared among multiple interfaces.
1461 if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1462 sc->vxl_im4o = malloc(sizeof(struct ip_moptions), M_VXLAN,
1464 sc->vxl_im4o->imo_multicast_ifp = sc->vxl_mc_ifp;
1465 sc->vxl_im4o->imo_multicast_ttl = sc->vxl_ttl;
1466 sc->vxl_im4o->imo_multicast_vif = -1;
1467 } else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1468 sc->vxl_im6o = malloc(sizeof(struct ip6_moptions), M_VXLAN,
1470 sc->vxl_im6o->im6o_multicast_ifp = sc->vxl_mc_ifp;
1471 sc->vxl_im6o->im6o_multicast_hlim = sc->vxl_ttl;
1478 vxlan_setup_socket(struct vxlan_softc *sc)
1480 struct vxlan_socket *vso;
1482 union vxlan_sockaddr *saddr, *daddr;
1483 int multicast, error;
1487 saddr = &sc->vxl_src_addr;
1488 daddr = &sc->vxl_dst_addr;
1490 multicast = vxlan_sockaddr_in_multicast(daddr);
1491 MPASS(multicast != -1);
1492 sc->vxl_vso_mc_index = -1;
1495 * Try to create the socket. If that fails, attempt to use an
1498 error = vxlan_socket_create(ifp, multicast, saddr, &vso);
1501 vso = vxlan_socket_mc_lookup(saddr);
1503 vso = vxlan_socket_lookup(saddr);
1506 if_printf(ifp, "cannot create socket (error: %d), "
1507 "and no existing socket found\n", error);
1512 if (multicast != 0) {
1513 error = vxlan_setup_multicast(sc);
1517 error = vxlan_socket_mc_add_group(vso, daddr, saddr,
1518 sc->vxl_mc_ifindex, &sc->vxl_vso_mc_index);
1524 error = vxlan_socket_insert_softc(vso, sc);
1526 sc->vxl_sock = NULL;
1527 if_printf(ifp, "network identifier %d already exists in "
1528 "this socket\n", sc->vxl_vni);
1536 if (sc->vxl_vso_mc_index != -1) {
1537 vxlan_socket_mc_release_group_by_idx(vso,
1538 sc->vxl_vso_mc_index);
1539 sc->vxl_vso_mc_index = -1;
1542 vxlan_free_multicast(sc);
1543 vxlan_socket_release(vso);
1550 vxlan_setup_interface(struct vxlan_softc *sc)
1555 ifp->if_hdrlen = ETHER_HDR_LEN + sizeof(struct vxlanudphdr);
1557 if (VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_dst_addr) != 0)
1558 ifp->if_hdrlen += sizeof(struct ip);
1559 else if (VXLAN_SOCKADDR_IS_IPV6(&sc->vxl_dst_addr) != 0)
1560 ifp->if_hdrlen += sizeof(struct ip6_hdr);
1564 vxlan_valid_init_config(struct vxlan_softc *sc)
1568 if (vxlan_check_vni(sc->vxl_vni) != 0) {
1569 reason = "invalid virtual network identifier specified";
1573 if (vxlan_sockaddr_supported(&sc->vxl_src_addr, 1) == 0) {
1574 reason = "source address type is not supported";
1578 if (vxlan_sockaddr_supported(&sc->vxl_dst_addr, 0) == 0) {
1579 reason = "destination address type is not supported";
1583 if (vxlan_sockaddr_in_any(&sc->vxl_dst_addr) != 0) {
1584 reason = "no valid destination address specified";
1588 if (vxlan_sockaddr_in_multicast(&sc->vxl_dst_addr) == 0 &&
1589 sc->vxl_mc_ifname[0] != '\0') {
1590 reason = "can only specify interface with a group address";
1594 if (vxlan_sockaddr_in_any(&sc->vxl_src_addr) == 0) {
1595 if (VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_src_addr) ^
1596 VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_dst_addr)) {
1597 reason = "source and destination address must both "
1598 "be either IPv4 or IPv6";
1603 if (sc->vxl_src_addr.in4.sin_port == 0) {
1604 reason = "local port not specified";
1608 if (sc->vxl_dst_addr.in4.sin_port == 0) {
1609 reason = "remote port not specified";
1616 if_printf(sc->vxl_ifp, "cannot initialize interface: %s\n", reason);
1621 vxlan_init_wait(struct vxlan_softc *sc)
1624 VXLAN_LOCK_WASSERT(sc);
1625 while (sc->vxl_flags & VXLAN_FLAG_INIT)
1626 rm_sleep(sc, &sc->vxl_lock, 0, "vxlint", hz);
1630 vxlan_init_complete(struct vxlan_softc *sc)
1634 sc->vxl_flags &= ~VXLAN_FLAG_INIT;
1640 vxlan_init(void *xsc)
1642 static const uint8_t empty_mac[ETHER_ADDR_LEN];
1643 struct vxlan_softc *sc;
1650 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1654 sc->vxl_flags |= VXLAN_FLAG_INIT;
1657 if (vxlan_valid_init_config(sc) != 0)
1660 vxlan_setup_interface(sc);
1662 if (vxlan_setup_socket(sc) != 0)
1665 /* Initialize the default forwarding entry. */
1666 vxlan_ftable_entry_init(sc, &sc->vxl_default_fe, empty_mac,
1667 &sc->vxl_dst_addr.sa, VXLAN_FE_FLAG_STATIC);
1670 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1671 callout_reset(&sc->vxl_callout, vxlan_ftable_prune_period * hz,
1675 if_link_state_change(ifp, LINK_STATE_UP);
1677 vxlan_init_complete(sc);
1681 vxlan_release(struct vxlan_softc *sc)
1685 * The softc may be destroyed as soon as we release our reference,
1686 * so we cannot serialize the wakeup with the softc lock. We use a
1687 * timeout in our sleeps so a missed wakeup is unfortunate but not
1690 if (VXLAN_RELEASE(sc) != 0)
1695 vxlan_teardown_wait(struct vxlan_softc *sc)
1698 VXLAN_LOCK_WASSERT(sc);
1699 while (sc->vxl_flags & VXLAN_FLAG_TEARDOWN)
1700 rm_sleep(sc, &sc->vxl_lock, 0, "vxltrn", hz);
1704 vxlan_teardown_complete(struct vxlan_softc *sc)
1708 sc->vxl_flags &= ~VXLAN_FLAG_TEARDOWN;
1714 vxlan_teardown_locked(struct vxlan_softc *sc)
1717 struct vxlan_socket *vso;
1721 VXLAN_LOCK_WASSERT(sc);
1722 MPASS(sc->vxl_flags & VXLAN_FLAG_TEARDOWN);
1724 ifp->if_flags &= ~IFF_UP;
1725 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1726 callout_stop(&sc->vxl_callout);
1728 sc->vxl_sock = NULL;
1731 if_link_state_change(ifp, LINK_STATE_DOWN);
1734 vxlan_socket_remove_softc(vso, sc);
1736 if (sc->vxl_vso_mc_index != -1) {
1737 vxlan_socket_mc_release_group_by_idx(vso,
1738 sc->vxl_vso_mc_index);
1739 sc->vxl_vso_mc_index = -1;
1744 while (sc->vxl_refcnt != 0)
1745 rm_sleep(sc, &sc->vxl_lock, 0, "vxldrn", hz);
1748 callout_drain(&sc->vxl_callout);
1750 vxlan_free_multicast(sc);
1752 vxlan_socket_release(vso);
1754 vxlan_teardown_complete(sc);
1758 vxlan_teardown(struct vxlan_softc *sc)
1762 if (sc->vxl_flags & VXLAN_FLAG_TEARDOWN) {
1763 vxlan_teardown_wait(sc);
1768 sc->vxl_flags |= VXLAN_FLAG_TEARDOWN;
1769 vxlan_teardown_locked(sc);
1773 vxlan_ifdetach(struct vxlan_softc *sc, struct ifnet *ifp,
1774 struct vxlan_softc_head *list)
1779 if (sc->vxl_mc_ifp != ifp)
1781 if (sc->vxl_flags & VXLAN_FLAG_TEARDOWN)
1784 sc->vxl_flags |= VXLAN_FLAG_TEARDOWN;
1785 LIST_INSERT_HEAD(list, sc, vxl_ifdetach_list);
1792 vxlan_timer(void *xsc)
1794 struct vxlan_softc *sc;
1797 VXLAN_LOCK_WASSERT(sc);
1799 vxlan_ftable_expire(sc);
1800 callout_schedule(&sc->vxl_callout, vxlan_ftable_prune_period * hz);
1804 vxlan_ioctl_ifflags(struct vxlan_softc *sc)
1810 if (ifp->if_flags & IFF_UP) {
1811 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1814 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1822 vxlan_ctrl_get_config(struct vxlan_softc *sc, void *arg)
1824 struct rm_priotracker tracker;
1825 struct ifvxlancfg *cfg;
1828 bzero(cfg, sizeof(*cfg));
1830 VXLAN_RLOCK(sc, &tracker);
1831 cfg->vxlc_vni = sc->vxl_vni;
1832 memcpy(&cfg->vxlc_local_sa, &sc->vxl_src_addr,
1833 sizeof(union vxlan_sockaddr));
1834 memcpy(&cfg->vxlc_remote_sa, &sc->vxl_dst_addr,
1835 sizeof(union vxlan_sockaddr));
1836 cfg->vxlc_mc_ifindex = sc->vxl_mc_ifindex;
1837 cfg->vxlc_ftable_cnt = sc->vxl_ftable_cnt;
1838 cfg->vxlc_ftable_max = sc->vxl_ftable_max;
1839 cfg->vxlc_ftable_timeout = sc->vxl_ftable_timeout;
1840 cfg->vxlc_port_min = sc->vxl_min_port;
1841 cfg->vxlc_port_max = sc->vxl_max_port;
1842 cfg->vxlc_learn = (sc->vxl_flags & VXLAN_FLAG_LEARN) != 0;
1843 cfg->vxlc_ttl = sc->vxl_ttl;
1844 VXLAN_RUNLOCK(sc, &tracker);
1847 if (VXLAN_SOCKADDR_IS_IPV6(&cfg->vxlc_local_sa))
1848 sa6_recoverscope(&cfg->vxlc_local_sa.in6);
1849 if (VXLAN_SOCKADDR_IS_IPV6(&cfg->vxlc_remote_sa))
1850 sa6_recoverscope(&cfg->vxlc_remote_sa.in6);
1857 vxlan_ctrl_set_vni(struct vxlan_softc *sc, void *arg)
1859 struct ifvxlancmd *cmd;
1864 if (vxlan_check_vni(cmd->vxlcmd_vni) != 0)
1868 if (vxlan_can_change_config(sc)) {
1869 sc->vxl_vni = cmd->vxlcmd_vni;
1879 vxlan_ctrl_set_local_addr(struct vxlan_softc *sc, void *arg)
1881 struct ifvxlancmd *cmd;
1882 union vxlan_sockaddr *vxlsa;
1886 vxlsa = &cmd->vxlcmd_sa;
1888 if (!VXLAN_SOCKADDR_IS_IPV46(vxlsa))
1890 if (vxlan_sockaddr_in_multicast(vxlsa) != 0)
1892 if (VXLAN_SOCKADDR_IS_IPV6(vxlsa)) {
1893 error = vxlan_sockaddr_in6_embedscope(vxlsa);
1899 if (vxlan_can_change_config(sc)) {
1900 vxlan_sockaddr_in_copy(&sc->vxl_src_addr, &vxlsa->sa);
1910 vxlan_ctrl_set_remote_addr(struct vxlan_softc *sc, void *arg)
1912 struct ifvxlancmd *cmd;
1913 union vxlan_sockaddr *vxlsa;
1917 vxlsa = &cmd->vxlcmd_sa;
1919 if (!VXLAN_SOCKADDR_IS_IPV46(vxlsa))
1921 if (VXLAN_SOCKADDR_IS_IPV6(vxlsa)) {
1922 error = vxlan_sockaddr_in6_embedscope(vxlsa);
1928 if (vxlan_can_change_config(sc)) {
1929 vxlan_sockaddr_in_copy(&sc->vxl_dst_addr, &vxlsa->sa);
1939 vxlan_ctrl_set_local_port(struct vxlan_softc *sc, void *arg)
1941 struct ifvxlancmd *cmd;
1946 if (cmd->vxlcmd_port == 0)
1950 if (vxlan_can_change_config(sc)) {
1951 sc->vxl_src_addr.in4.sin_port = htons(cmd->vxlcmd_port);
1961 vxlan_ctrl_set_remote_port(struct vxlan_softc *sc, void *arg)
1963 struct ifvxlancmd *cmd;
1968 if (cmd->vxlcmd_port == 0)
1972 if (vxlan_can_change_config(sc)) {
1973 sc->vxl_dst_addr.in4.sin_port = htons(cmd->vxlcmd_port);
1983 vxlan_ctrl_set_port_range(struct vxlan_softc *sc, void *arg)
1985 struct ifvxlancmd *cmd;
1990 min = cmd->vxlcmd_port_min;
1991 max = cmd->vxlcmd_port_max;
1997 if (vxlan_can_change_config(sc)) {
1998 sc->vxl_min_port = min;
1999 sc->vxl_max_port = max;
2009 vxlan_ctrl_set_ftable_timeout(struct vxlan_softc *sc, void *arg)
2011 struct ifvxlancmd *cmd;
2017 if (vxlan_check_ftable_timeout(cmd->vxlcmd_ftable_timeout) == 0) {
2018 sc->vxl_ftable_timeout = cmd->vxlcmd_ftable_timeout;
2028 vxlan_ctrl_set_ftable_max(struct vxlan_softc *sc, void *arg)
2030 struct ifvxlancmd *cmd;
2036 if (vxlan_check_ftable_max(cmd->vxlcmd_ftable_max) == 0) {
2037 sc->vxl_ftable_max = cmd->vxlcmd_ftable_max;
2047 vxlan_ctrl_set_multicast_if(struct vxlan_softc * sc, void *arg)
2049 struct ifvxlancmd *cmd;
2055 if (vxlan_can_change_config(sc)) {
2056 strlcpy(sc->vxl_mc_ifname, cmd->vxlcmd_ifname, IFNAMSIZ);
2066 vxlan_ctrl_set_ttl(struct vxlan_softc *sc, void *arg)
2068 struct ifvxlancmd *cmd;
2074 if (vxlan_check_ttl(cmd->vxlcmd_ttl) == 0) {
2075 sc->vxl_ttl = cmd->vxlcmd_ttl;
2076 if (sc->vxl_im4o != NULL)
2077 sc->vxl_im4o->imo_multicast_ttl = sc->vxl_ttl;
2078 if (sc->vxl_im6o != NULL)
2079 sc->vxl_im6o->im6o_multicast_hlim = sc->vxl_ttl;
2089 vxlan_ctrl_set_learn(struct vxlan_softc *sc, void *arg)
2091 struct ifvxlancmd *cmd;
2096 if (cmd->vxlcmd_flags & VXLAN_CMD_FLAG_LEARN)
2097 sc->vxl_flags |= VXLAN_FLAG_LEARN;
2099 sc->vxl_flags &= ~VXLAN_FLAG_LEARN;
2106 vxlan_ctrl_ftable_entry_add(struct vxlan_softc *sc, void *arg)
2108 union vxlan_sockaddr vxlsa;
2109 struct ifvxlancmd *cmd;
2110 struct vxlan_ftable_entry *fe;
2114 vxlsa = cmd->vxlcmd_sa;
2116 if (!VXLAN_SOCKADDR_IS_IPV46(&vxlsa))
2118 if (vxlan_sockaddr_in_any(&vxlsa) != 0)
2120 if (vxlan_sockaddr_in_multicast(&vxlsa) != 0)
2122 /* BMV: We could support both IPv4 and IPv6 later. */
2123 if (vxlsa.sa.sa_family != sc->vxl_dst_addr.sa.sa_family)
2124 return (EAFNOSUPPORT);
2126 if (VXLAN_SOCKADDR_IS_IPV6(&vxlsa)) {
2127 error = vxlan_sockaddr_in6_embedscope(&vxlsa);
2132 fe = vxlan_ftable_entry_alloc();
2136 if (vxlsa.in4.sin_port == 0)
2137 vxlsa.in4.sin_port = sc->vxl_dst_addr.in4.sin_port;
2139 vxlan_ftable_entry_init(sc, fe, cmd->vxlcmd_mac, &vxlsa.sa,
2140 VXLAN_FE_FLAG_STATIC);
2143 error = vxlan_ftable_entry_insert(sc, fe);
2147 vxlan_ftable_entry_free(fe);
2153 vxlan_ctrl_ftable_entry_rem(struct vxlan_softc *sc, void *arg)
2155 struct ifvxlancmd *cmd;
2156 struct vxlan_ftable_entry *fe;
2162 fe = vxlan_ftable_entry_lookup(sc, cmd->vxlcmd_mac);
2164 vxlan_ftable_entry_destroy(sc, fe);
2174 vxlan_ctrl_flush(struct vxlan_softc *sc, void *arg)
2176 struct ifvxlancmd *cmd;
2180 all = cmd->vxlcmd_flags & VXLAN_CMD_FLAG_FLUSH_ALL;
2183 vxlan_ftable_flush(sc, all);
2190 vxlan_ioctl_drvspec(struct vxlan_softc *sc, struct ifdrv *ifd, int get)
2192 const struct vxlan_control *vc;
2194 struct ifvxlancfg cfg;
2195 struct ifvxlancmd cmd;
2199 if (ifd->ifd_cmd >= vxlan_control_table_size)
2202 bzero(&args, sizeof(args));
2203 vc = &vxlan_control_table[ifd->ifd_cmd];
2204 out = (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYOUT) != 0;
2206 if ((get != 0 && out == 0) || (get == 0 && out != 0))
2209 if (vc->vxlc_flags & VXLAN_CTRL_FLAG_SUSER) {
2210 error = priv_check(curthread, PRIV_NET_VXLAN);
2215 if (ifd->ifd_len != vc->vxlc_argsize ||
2216 ifd->ifd_len > sizeof(args))
2219 if (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYIN) {
2220 error = copyin(ifd->ifd_data, &args, ifd->ifd_len);
2225 error = vc->vxlc_func(sc, &args);
2229 if (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYOUT) {
2230 error = copyout(&args, ifd->ifd_data, ifd->ifd_len);
2239 vxlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2241 struct vxlan_softc *sc;
2247 ifr = (struct ifreq *) data;
2248 ifd = (struct ifdrv *) data;
2258 error = vxlan_ioctl_drvspec(sc, ifd, cmd == SIOCGDRVSPEC);
2262 error = vxlan_ioctl_ifflags(sc);
2267 error = ifmedia_ioctl(ifp, ifr, &sc->vxl_media, cmd);
2271 error = ether_ioctl(ifp, cmd, data);
2278 #if defined(INET) || defined(INET6)
2280 vxlan_pick_source_port(struct vxlan_softc *sc, struct mbuf *m)
2285 range = sc->vxl_max_port - sc->vxl_min_port + 1;
2287 if (M_HASHTYPE_ISHASH(m))
2288 hash = m->m_pkthdr.flowid;
2290 hash = jenkins_hash(m->m_data, ETHER_HDR_LEN,
2291 sc->vxl_port_hash_key);
2293 return (sc->vxl_min_port + (hash % range));
2297 vxlan_encap_header(struct vxlan_softc *sc, struct mbuf *m, int ipoff,
2298 uint16_t srcport, uint16_t dstport)
2300 struct vxlanudphdr *hdr;
2301 struct udphdr *udph;
2302 struct vxlan_header *vxh;
2305 len = m->m_pkthdr.len - ipoff;
2306 MPASS(len >= sizeof(struct vxlanudphdr));
2307 hdr = mtodo(m, ipoff);
2309 udph = &hdr->vxlh_udp;
2310 udph->uh_sport = srcport;
2311 udph->uh_dport = dstport;
2312 udph->uh_ulen = htons(len);
2315 vxh = &hdr->vxlh_hdr;
2316 vxh->vxlh_flags = htonl(VXLAN_HDR_FLAGS_VALID_VNI);
2317 vxh->vxlh_vni = htonl(sc->vxl_vni << VXLAN_HDR_VNI_SHIFT);
2322 vxlan_encap4(struct vxlan_softc *sc, const union vxlan_sockaddr *fvxlsa,
2328 struct in_addr srcaddr, dstaddr;
2329 uint16_t srcport, dstport;
2330 int len, mcast, error;
2333 srcaddr = sc->vxl_src_addr.in4.sin_addr;
2334 srcport = vxlan_pick_source_port(sc, m);
2335 dstaddr = fvxlsa->in4.sin_addr;
2336 dstport = fvxlsa->in4.sin_port;
2338 M_PREPEND(m, sizeof(struct ip) + sizeof(struct vxlanudphdr),
2341 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2345 len = m->m_pkthdr.len;
2347 ip = mtod(m, struct ip *);
2349 ip->ip_len = htons(len);
2351 ip->ip_ttl = sc->vxl_ttl;
2352 ip->ip_p = IPPROTO_UDP;
2354 ip->ip_src = srcaddr;
2355 ip->ip_dst = dstaddr;
2357 vxlan_encap_header(sc, m, sizeof(struct ip), srcport, dstport);
2359 mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0;
2360 m->m_flags &= ~(M_MCAST | M_BCAST);
2362 error = ip_output(m, NULL, NULL, 0, sc->vxl_im4o, NULL);
2364 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2365 if_inc_counter(ifp, IFCOUNTER_OBYTES, len);
2367 if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
2369 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2379 vxlan_encap6(struct vxlan_softc *sc, const union vxlan_sockaddr *fvxlsa,
2384 struct ip6_hdr *ip6;
2385 const struct in6_addr *srcaddr, *dstaddr;
2386 uint16_t srcport, dstport;
2387 int len, mcast, error;
2390 srcaddr = &sc->vxl_src_addr.in6.sin6_addr;
2391 srcport = vxlan_pick_source_port(sc, m);
2392 dstaddr = &fvxlsa->in6.sin6_addr;
2393 dstport = fvxlsa->in6.sin6_port;
2395 M_PREPEND(m, sizeof(struct ip6_hdr) + sizeof(struct vxlanudphdr),
2398 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2402 len = m->m_pkthdr.len;
2404 ip6 = mtod(m, struct ip6_hdr *);
2405 ip6->ip6_flow = 0; /* BMV: Keep in forwarding entry? */
2406 ip6->ip6_vfc = IPV6_VERSION;
2408 ip6->ip6_nxt = IPPROTO_UDP;
2409 ip6->ip6_hlim = sc->vxl_ttl;
2410 ip6->ip6_src = *srcaddr;
2411 ip6->ip6_dst = *dstaddr;
2413 vxlan_encap_header(sc, m, sizeof(struct ip6_hdr), srcport, dstport);
2416 * XXX BMV We need support for RFC6935 before we can send and
2417 * receive IPv6 UDP packets with a zero checksum.
2420 struct udphdr *hdr = mtodo(m, sizeof(struct ip6_hdr));
2421 hdr->uh_sum = in6_cksum_pseudo(ip6,
2422 m->m_pkthdr.len - sizeof(struct ip6_hdr), IPPROTO_UDP, 0);
2423 m->m_pkthdr.csum_flags = CSUM_UDP_IPV6;
2424 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
2427 mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0;
2428 m->m_flags &= ~(M_MCAST | M_BCAST);
2430 error = ip6_output(m, NULL, NULL, 0, sc->vxl_im6o, NULL, NULL);
2432 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2433 if_inc_counter(ifp, IFCOUNTER_OBYTES, len);
2435 if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
2437 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2447 vxlan_transmit(struct ifnet *ifp, struct mbuf *m)
2449 struct rm_priotracker tracker;
2450 union vxlan_sockaddr vxlsa;
2451 struct vxlan_softc *sc;
2452 struct vxlan_ftable_entry *fe;
2453 struct ifnet *mcifp;
2454 struct ether_header *eh;
2458 eh = mtod(m, struct ether_header *);
2462 ETHER_BPF_MTAP(ifp, m);
2464 VXLAN_RLOCK(sc, &tracker);
2465 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
2466 VXLAN_RUNLOCK(sc, &tracker);
2471 if ((m->m_flags & (M_BCAST | M_MCAST)) == 0)
2472 fe = vxlan_ftable_entry_lookup(sc, eh->ether_dhost);
2474 fe = &sc->vxl_default_fe;
2475 vxlan_sockaddr_copy(&vxlsa, &fe->vxlfe_raddr.sa);
2477 ipv4 = VXLAN_SOCKADDR_IS_IPV4(&vxlsa) != 0;
2478 if (vxlan_sockaddr_in_multicast(&vxlsa) != 0)
2479 mcifp = vxlan_multicast_if_ref(sc, ipv4);
2482 VXLAN_RUNLOCK(sc, &tracker);
2485 error = vxlan_encap4(sc, &vxlsa, m);
2487 error = vxlan_encap6(sc, &vxlsa, m);
2497 vxlan_qflush(struct ifnet *ifp __unused)
2502 vxlan_rcv_udp_packet(struct mbuf *m, int offset, struct inpcb *inpcb,
2503 const struct sockaddr *srcsa, void *xvso)
2505 struct vxlan_socket *vso;
2506 struct vxlan_header *vxh, vxlanhdr;
2512 offset += sizeof(struct udphdr);
2514 if (m->m_pkthdr.len < offset + sizeof(struct vxlan_header))
2517 if (__predict_false(m->m_len < offset + sizeof(struct vxlan_header))) {
2518 m_copydata(m, offset, sizeof(struct vxlan_header),
2519 (caddr_t) &vxlanhdr);
2522 vxh = mtodo(m, offset);
2525 * Drop if there is a reserved bit set in either the flags or VNI
2526 * fields of the header. This goes against the specification, but
2527 * a bit set may indicate an unsupported new feature. This matches
2528 * the behavior of the Linux implementation.
2530 if (vxh->vxlh_flags != htonl(VXLAN_HDR_FLAGS_VALID_VNI) ||
2531 vxh->vxlh_vni & ~htonl(VXLAN_VNI_MASK))
2534 vni = ntohl(vxh->vxlh_vni) >> VXLAN_HDR_VNI_SHIFT;
2536 /* Adjust to the start of the inner Ethernet frame. */
2537 m_adj_decap(m, offset + sizeof(struct vxlan_header));
2539 error = vxlan_input(vso, vni, &m, srcsa);
2540 MPASS(error != 0 || m == NULL);
2548 vxlan_input(struct vxlan_socket *vso, uint32_t vni, struct mbuf **m0,
2549 const struct sockaddr *sa)
2551 struct vxlan_softc *sc;
2554 struct ether_header *eh;
2557 sc = vxlan_socket_lookup_softc(vso, vni);
2563 eh = mtod(m, struct ether_header *);
2565 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
2568 } else if (ifp == m->m_pkthdr.rcvif) {
2569 /* XXX Does not catch more complex loops. */
2574 if (sc->vxl_flags & VXLAN_FLAG_LEARN)
2575 vxlan_ftable_learn(sc, sa, eh->ether_shost);
2578 m->m_pkthdr.rcvif = ifp;
2579 M_SETFIB(m, ifp->if_fib);
2581 error = netisr_queue_src(NETISR_ETHER, 0, m);
2590 vxlan_set_default_config(struct vxlan_softc *sc)
2593 sc->vxl_flags |= VXLAN_FLAG_LEARN;
2595 sc->vxl_vni = VXLAN_VNI_MAX;
2596 sc->vxl_ttl = IPDEFTTL;
2598 if (!vxlan_tunable_int(sc, "legacy_port", vxlan_legacy_port)) {
2599 sc->vxl_src_addr.in4.sin_port = htons(VXLAN_PORT);
2600 sc->vxl_dst_addr.in4.sin_port = htons(VXLAN_PORT);
2602 sc->vxl_src_addr.in4.sin_port = htons(VXLAN_LEGACY_PORT);
2603 sc->vxl_dst_addr.in4.sin_port = htons(VXLAN_LEGACY_PORT);
2606 sc->vxl_min_port = V_ipport_firstauto;
2607 sc->vxl_max_port = V_ipport_lastauto;
2609 sc->vxl_ftable_max = VXLAN_FTABLE_MAX;
2610 sc->vxl_ftable_timeout = VXLAN_FTABLE_TIMEOUT;
2614 vxlan_set_user_config(struct vxlan_softc *sc, struct ifvxlanparam *vxlp)
2618 if (vxlp->vxlp_with & (VXLAN_PARAM_WITH_LOCAL_ADDR4 |
2619 VXLAN_PARAM_WITH_REMOTE_ADDR4))
2620 return (EAFNOSUPPORT);
2624 if (vxlp->vxlp_with & (VXLAN_PARAM_WITH_LOCAL_ADDR6 |
2625 VXLAN_PARAM_WITH_REMOTE_ADDR6))
2626 return (EAFNOSUPPORT);
2628 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR6) {
2629 int error = vxlan_sockaddr_in6_embedscope(&vxlp->vxlp_local_sa);
2633 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR6) {
2634 int error = vxlan_sockaddr_in6_embedscope(
2635 &vxlp->vxlp_remote_sa);
2641 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_VNI) {
2642 if (vxlan_check_vni(vxlp->vxlp_vni) == 0)
2643 sc->vxl_vni = vxlp->vxlp_vni;
2646 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR4) {
2647 sc->vxl_src_addr.in4.sin_len = sizeof(struct sockaddr_in);
2648 sc->vxl_src_addr.in4.sin_family = AF_INET;
2649 sc->vxl_src_addr.in4.sin_addr =
2650 vxlp->vxlp_local_sa.in4.sin_addr;
2651 } else if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_ADDR6) {
2652 sc->vxl_src_addr.in6.sin6_len = sizeof(struct sockaddr_in6);
2653 sc->vxl_src_addr.in6.sin6_family = AF_INET6;
2654 sc->vxl_src_addr.in6.sin6_addr =
2655 vxlp->vxlp_local_sa.in6.sin6_addr;
2658 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR4) {
2659 sc->vxl_dst_addr.in4.sin_len = sizeof(struct sockaddr_in);
2660 sc->vxl_dst_addr.in4.sin_family = AF_INET;
2661 sc->vxl_dst_addr.in4.sin_addr =
2662 vxlp->vxlp_remote_sa.in4.sin_addr;
2663 } else if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_ADDR6) {
2664 sc->vxl_dst_addr.in6.sin6_len = sizeof(struct sockaddr_in6);
2665 sc->vxl_dst_addr.in6.sin6_family = AF_INET6;
2666 sc->vxl_dst_addr.in6.sin6_addr =
2667 vxlp->vxlp_remote_sa.in6.sin6_addr;
2670 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LOCAL_PORT)
2671 sc->vxl_src_addr.in4.sin_port = htons(vxlp->vxlp_local_port);
2672 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_REMOTE_PORT)
2673 sc->vxl_dst_addr.in4.sin_port = htons(vxlp->vxlp_remote_port);
2675 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_PORT_RANGE) {
2676 if (vxlp->vxlp_min_port <= vxlp->vxlp_max_port) {
2677 sc->vxl_min_port = vxlp->vxlp_min_port;
2678 sc->vxl_max_port = vxlp->vxlp_max_port;
2682 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_MULTICAST_IF)
2683 strlcpy(sc->vxl_mc_ifname, vxlp->vxlp_mc_ifname, IFNAMSIZ);
2685 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_FTABLE_TIMEOUT) {
2686 if (vxlan_check_ftable_timeout(vxlp->vxlp_ftable_timeout) == 0)
2687 sc->vxl_ftable_timeout = vxlp->vxlp_ftable_timeout;
2690 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_FTABLE_MAX) {
2691 if (vxlan_check_ftable_max(vxlp->vxlp_ftable_max) == 0)
2692 sc->vxl_ftable_max = vxlp->vxlp_ftable_max;
2695 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_TTL) {
2696 if (vxlan_check_ttl(vxlp->vxlp_ttl) == 0)
2697 sc->vxl_ttl = vxlp->vxlp_ttl;
2700 if (vxlp->vxlp_with & VXLAN_PARAM_WITH_LEARN) {
2701 if (vxlp->vxlp_learn == 0)
2702 sc->vxl_flags &= ~VXLAN_FLAG_LEARN;
2709 vxlan_clone_create(struct if_clone *ifc, int unit, caddr_t params)
2711 struct vxlan_softc *sc;
2713 struct ifvxlanparam vxlp;
2716 sc = malloc(sizeof(struct vxlan_softc), M_VXLAN, M_WAITOK | M_ZERO);
2717 sc->vxl_unit = unit;
2718 vxlan_set_default_config(sc);
2721 error = copyin(params, &vxlp, sizeof(vxlp));
2725 error = vxlan_set_user_config(sc, &vxlp);
2730 ifp = if_alloc(IFT_ETHER);
2737 rm_init(&sc->vxl_lock, "vxlanrm");
2738 callout_init_rw(&sc->vxl_callout, &sc->vxl_lock, 0);
2739 sc->vxl_port_hash_key = arc4random();
2740 vxlan_ftable_init(sc);
2742 vxlan_sysctl_setup(sc);
2745 if_initname(ifp, vxlan_name, unit);
2746 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
2747 ifp->if_init = vxlan_init;
2748 ifp->if_ioctl = vxlan_ioctl;
2749 ifp->if_transmit = vxlan_transmit;
2750 ifp->if_qflush = vxlan_qflush;
2751 ifp->if_capabilities |= IFCAP_LINKSTATE;
2752 ifp->if_capenable |= IFCAP_LINKSTATE;
2754 ifmedia_init(&sc->vxl_media, 0, vxlan_media_change, vxlan_media_status);
2755 ifmedia_add(&sc->vxl_media, IFM_ETHER | IFM_AUTO, 0, NULL);
2756 ifmedia_set(&sc->vxl_media, IFM_ETHER | IFM_AUTO);
2758 ether_gen_addr(ifp, &sc->vxl_hwaddr);
2759 ether_ifattach(ifp, sc->vxl_hwaddr.octet);
2761 ifp->if_baudrate = 0;
2772 vxlan_clone_destroy(struct ifnet *ifp)
2774 struct vxlan_softc *sc;
2780 vxlan_ftable_flush(sc, 1);
2782 ether_ifdetach(ifp);
2784 ifmedia_removeall(&sc->vxl_media);
2786 vxlan_ftable_fini(sc);
2788 vxlan_sysctl_destroy(sc);
2789 rm_destroy(&sc->vxl_lock);
2793 /* BMV: Taken from if_bridge. */
2795 vxlan_mac_hash(struct vxlan_softc *sc, const uint8_t *addr)
2797 uint32_t a = 0x9e3779b9, b = 0x9e3779b9, c = sc->vxl_ftable_hash_key;
2807 * The following hash function is adapted from "Hash Functions" by Bob Jenkins
2808 * ("Algorithm Alley", Dr. Dobbs Journal, September 1997).
2810 #define mix(a, b, c) \
2812 a -= b; a -= c; a ^= (c >> 13); \
2813 b -= c; b -= a; b ^= (a << 8); \
2814 c -= a; c -= b; c ^= (b >> 13); \
2815 a -= b; a -= c; a ^= (c >> 12); \
2816 b -= c; b -= a; b ^= (a << 16); \
2817 c -= a; c -= b; c ^= (b >> 5); \
2818 a -= b; a -= c; a ^= (c >> 3); \
2819 b -= c; b -= a; b ^= (a << 10); \
2820 c -= a; c -= b; c ^= (b >> 15); \
2831 vxlan_media_change(struct ifnet *ifp)
2839 vxlan_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
2842 ifmr->ifm_status = IFM_ACTIVE | IFM_AVALID;
2843 ifmr->ifm_active = IFM_ETHER | IFM_FDX;
2847 vxlan_sockaddr_cmp(const union vxlan_sockaddr *vxladdr,
2848 const struct sockaddr *sa)
2851 return (bcmp(&vxladdr->sa, sa, vxladdr->sa.sa_len));
2855 vxlan_sockaddr_copy(union vxlan_sockaddr *vxladdr,
2856 const struct sockaddr *sa)
2859 MPASS(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
2860 bzero(vxladdr, sizeof(*vxladdr));
2862 if (sa->sa_family == AF_INET) {
2863 vxladdr->in4 = *satoconstsin(sa);
2864 vxladdr->in4.sin_len = sizeof(struct sockaddr_in);
2865 } else if (sa->sa_family == AF_INET6) {
2866 vxladdr->in6 = *satoconstsin6(sa);
2867 vxladdr->in6.sin6_len = sizeof(struct sockaddr_in6);
2872 vxlan_sockaddr_in_equal(const union vxlan_sockaddr *vxladdr,
2873 const struct sockaddr *sa)
2877 if (sa->sa_family == AF_INET) {
2878 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2879 equal = in4->s_addr == vxladdr->in4.sin_addr.s_addr;
2880 } else if (sa->sa_family == AF_INET6) {
2881 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2882 equal = IN6_ARE_ADDR_EQUAL(in6, &vxladdr->in6.sin6_addr);
2890 vxlan_sockaddr_in_copy(union vxlan_sockaddr *vxladdr,
2891 const struct sockaddr *sa)
2894 MPASS(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
2896 if (sa->sa_family == AF_INET) {
2897 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2898 vxladdr->in4.sin_family = AF_INET;
2899 vxladdr->in4.sin_len = sizeof(struct sockaddr_in);
2900 vxladdr->in4.sin_addr = *in4;
2901 } else if (sa->sa_family == AF_INET6) {
2902 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2903 vxladdr->in6.sin6_family = AF_INET6;
2904 vxladdr->in6.sin6_len = sizeof(struct sockaddr_in6);
2905 vxladdr->in6.sin6_addr = *in6;
2910 vxlan_sockaddr_supported(const union vxlan_sockaddr *vxladdr, int unspec)
2912 const struct sockaddr *sa;
2918 if (sa->sa_family == AF_UNSPEC && unspec != 0) {
2920 } else if (sa->sa_family == AF_INET) {
2924 } else if (sa->sa_family == AF_INET6) {
2934 vxlan_sockaddr_in_any(const union vxlan_sockaddr *vxladdr)
2936 const struct sockaddr *sa;
2941 if (sa->sa_family == AF_INET) {
2942 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2943 any = in4->s_addr == INADDR_ANY;
2944 } else if (sa->sa_family == AF_INET6) {
2945 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2946 any = IN6_IS_ADDR_UNSPECIFIED(in6);
2954 vxlan_sockaddr_in_multicast(const union vxlan_sockaddr *vxladdr)
2956 const struct sockaddr *sa;
2961 if (sa->sa_family == AF_INET) {
2962 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2963 mc = IN_MULTICAST(ntohl(in4->s_addr));
2964 } else if (sa->sa_family == AF_INET6) {
2965 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2966 mc = IN6_IS_ADDR_MULTICAST(in6);
2974 vxlan_sockaddr_in6_embedscope(union vxlan_sockaddr *vxladdr)
2978 MPASS(VXLAN_SOCKADDR_IS_IPV6(vxladdr));
2980 error = sa6_embedscope(&vxladdr->in6, V_ip6_use_defzone);
2982 error = EAFNOSUPPORT;
2989 vxlan_can_change_config(struct vxlan_softc *sc)
2994 VXLAN_LOCK_ASSERT(sc);
2996 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
2998 if (sc->vxl_flags & (VXLAN_FLAG_INIT | VXLAN_FLAG_TEARDOWN))
3005 vxlan_check_vni(uint32_t vni)
3008 return (vni >= VXLAN_VNI_MAX);
3012 vxlan_check_ttl(int ttl)
3015 return (ttl > MAXTTL);
3019 vxlan_check_ftable_timeout(uint32_t timeout)
3022 return (timeout > VXLAN_FTABLE_MAX_TIMEOUT);
3026 vxlan_check_ftable_max(uint32_t max)
3029 return (max > VXLAN_FTABLE_MAX);
3033 vxlan_sysctl_setup(struct vxlan_softc *sc)
3035 struct sysctl_ctx_list *ctx;
3036 struct sysctl_oid *node;
3037 struct vxlan_statistics *stats;
3040 ctx = &sc->vxl_sysctl_ctx;
3041 stats = &sc->vxl_stats;
3042 snprintf(namebuf, sizeof(namebuf), "%d", sc->vxl_unit);
3044 sysctl_ctx_init(ctx);
3045 sc->vxl_sysctl_node = SYSCTL_ADD_NODE(ctx,
3046 SYSCTL_STATIC_CHILDREN(_net_link_vxlan), OID_AUTO, namebuf,
3047 CTLFLAG_RD, NULL, "");
3049 node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sc->vxl_sysctl_node),
3050 OID_AUTO, "ftable", CTLFLAG_RD, NULL, "");
3051 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "count",
3052 CTLFLAG_RD, &sc->vxl_ftable_cnt, 0,
3053 "Number of entries in fowarding table");
3054 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "max",
3055 CTLFLAG_RD, &sc->vxl_ftable_max, 0,
3056 "Maximum number of entries allowed in fowarding table");
3057 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "timeout",
3058 CTLFLAG_RD, &sc->vxl_ftable_timeout, 0,
3059 "Number of seconds between prunes of the forwarding table");
3060 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "dump",
3061 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_SKIP,
3062 sc, 0, vxlan_ftable_sysctl_dump, "A",
3063 "Dump the forwarding table entries");
3065 node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sc->vxl_sysctl_node),
3066 OID_AUTO, "stats", CTLFLAG_RD, NULL, "");
3067 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
3068 "ftable_nospace", CTLFLAG_RD, &stats->ftable_nospace, 0,
3069 "Fowarding table reached maximum entries");
3070 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
3071 "ftable_lock_upgrade_failed", CTLFLAG_RD,
3072 &stats->ftable_lock_upgrade_failed, 0,
3073 "Forwarding table update required lock upgrade");
3077 vxlan_sysctl_destroy(struct vxlan_softc *sc)
3080 sysctl_ctx_free(&sc->vxl_sysctl_ctx);
3081 sc->vxl_sysctl_node = NULL;
3085 vxlan_tunable_int(struct vxlan_softc *sc, const char *knob, int def)
3089 snprintf(path, sizeof(path), "net.link.vxlan.%d.%s",
3090 sc->vxl_unit, knob);
3091 TUNABLE_INT_FETCH(path, &def);
3097 vxlan_ifdetach_event(void *arg __unused, struct ifnet *ifp)
3099 struct vxlan_softc_head list;
3100 struct vxlan_socket *vso;
3101 struct vxlan_softc *sc, *tsc;
3105 if (ifp->if_flags & IFF_RENAMING)
3107 if ((ifp->if_flags & IFF_MULTICAST) == 0)
3111 LIST_FOREACH(vso, &vxlan_socket_list, vxlso_entry)
3112 vxlan_socket_ifdetach(vso, ifp, &list);
3113 VXLAN_LIST_UNLOCK();
3115 LIST_FOREACH_SAFE(sc, &list, vxl_ifdetach_list, tsc) {
3116 LIST_REMOVE(sc, vxl_ifdetach_list);
3119 if (sc->vxl_flags & VXLAN_FLAG_INIT)
3120 vxlan_init_wait(sc);
3121 vxlan_teardown_locked(sc);
3129 mtx_init(&vxlan_list_mtx, "vxlan list", NULL, MTX_DEF);
3130 LIST_INIT(&vxlan_socket_list);
3131 vxlan_ifdetach_event_tag = EVENTHANDLER_REGISTER(ifnet_departure_event,
3132 vxlan_ifdetach_event, NULL, EVENTHANDLER_PRI_ANY);
3133 vxlan_cloner = if_clone_simple(vxlan_name, vxlan_clone_create,
3134 vxlan_clone_destroy, 0);
3141 EVENTHANDLER_DEREGISTER(ifnet_departure_event,
3142 vxlan_ifdetach_event_tag);
3143 if_clone_detach(vxlan_cloner);
3144 mtx_destroy(&vxlan_list_mtx);
3145 MPASS(LIST_EMPTY(&vxlan_socket_list));
3149 vxlan_modevent(module_t mod, int type, void *unused)
3170 static moduledata_t vxlan_mod = {
3176 DECLARE_MODULE(if_vxlan, vxlan_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
3177 MODULE_VERSION(if_vxlan, 1);