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 uint8_t vxl_hwaddr[ETHER_ADDR_LEN];
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 void vxlan_fakeaddr(struct vxlan_softc *);
349 static int vxlan_media_change(struct ifnet *);
350 static void vxlan_media_status(struct ifnet *, struct ifmediareq *);
352 static int vxlan_sockaddr_cmp(const union vxlan_sockaddr *,
353 const struct sockaddr *);
354 static void vxlan_sockaddr_copy(union vxlan_sockaddr *,
355 const struct sockaddr *);
356 static int vxlan_sockaddr_in_equal(const union vxlan_sockaddr *,
357 const struct sockaddr *);
358 static void vxlan_sockaddr_in_copy(union vxlan_sockaddr *,
359 const struct sockaddr *);
360 static int vxlan_sockaddr_supported(const union vxlan_sockaddr *, int);
361 static int vxlan_sockaddr_in_any(const union vxlan_sockaddr *);
362 static int vxlan_sockaddr_in_multicast(const union vxlan_sockaddr *);
363 static int vxlan_sockaddr_in6_embedscope(union vxlan_sockaddr *);
365 static int vxlan_can_change_config(struct vxlan_softc *);
366 static int vxlan_check_vni(uint32_t);
367 static int vxlan_check_ttl(int);
368 static int vxlan_check_ftable_timeout(uint32_t);
369 static int vxlan_check_ftable_max(uint32_t);
371 static void vxlan_sysctl_setup(struct vxlan_softc *);
372 static void vxlan_sysctl_destroy(struct vxlan_softc *);
373 static int vxlan_tunable_int(struct vxlan_softc *, const char *, int);
375 static void vxlan_ifdetach_event(void *, struct ifnet *);
376 static void vxlan_load(void);
377 static void vxlan_unload(void);
378 static int vxlan_modevent(module_t, int, void *);
380 static const char vxlan_name[] = "vxlan";
381 static MALLOC_DEFINE(M_VXLAN, vxlan_name,
382 "Virtual eXtensible LAN Interface");
383 static struct if_clone *vxlan_cloner;
385 static struct mtx vxlan_list_mtx;
386 #define VXLAN_LIST_LOCK() mtx_lock(&vxlan_list_mtx)
387 #define VXLAN_LIST_UNLOCK() mtx_unlock(&vxlan_list_mtx)
389 static LIST_HEAD(, vxlan_socket) vxlan_socket_list;
391 static eventhandler_tag vxlan_ifdetach_event_tag;
393 SYSCTL_DECL(_net_link);
394 SYSCTL_NODE(_net_link, OID_AUTO, vxlan, CTLFLAG_RW, 0,
395 "Virtual eXtensible Local Area Network");
397 static int vxlan_legacy_port = 0;
398 TUNABLE_INT("net.link.vxlan.legacy_port", &vxlan_legacy_port);
399 static int vxlan_reuse_port = 0;
400 TUNABLE_INT("net.link.vxlan.reuse_port", &vxlan_reuse_port);
402 /* Default maximum number of addresses in the forwarding table. */
403 #ifndef VXLAN_FTABLE_MAX
404 #define VXLAN_FTABLE_MAX 2000
407 /* Timeout (in seconds) of addresses learned in the forwarding table. */
408 #ifndef VXLAN_FTABLE_TIMEOUT
409 #define VXLAN_FTABLE_TIMEOUT (20 * 60)
413 * Maximum timeout (in seconds) of addresses learned in the forwarding
416 #ifndef VXLAN_FTABLE_MAX_TIMEOUT
417 #define VXLAN_FTABLE_MAX_TIMEOUT (60 * 60 * 24)
420 /* Number of seconds between pruning attempts of the forwarding table. */
421 #ifndef VXLAN_FTABLE_PRUNE
422 #define VXLAN_FTABLE_PRUNE (5 * 60)
425 static int vxlan_ftable_prune_period = VXLAN_FTABLE_PRUNE;
427 struct vxlan_control {
428 int (*vxlc_func)(struct vxlan_softc *, void *);
431 #define VXLAN_CTRL_FLAG_COPYIN 0x01
432 #define VXLAN_CTRL_FLAG_COPYOUT 0x02
433 #define VXLAN_CTRL_FLAG_SUSER 0x04
436 static const struct vxlan_control vxlan_control_table[] = {
437 [VXLAN_CMD_GET_CONFIG] =
438 { vxlan_ctrl_get_config, sizeof(struct ifvxlancfg),
439 VXLAN_CTRL_FLAG_COPYOUT
442 [VXLAN_CMD_SET_VNI] =
443 { vxlan_ctrl_set_vni, sizeof(struct ifvxlancmd),
444 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
447 [VXLAN_CMD_SET_LOCAL_ADDR] =
448 { vxlan_ctrl_set_local_addr, sizeof(struct ifvxlancmd),
449 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
452 [VXLAN_CMD_SET_REMOTE_ADDR] =
453 { vxlan_ctrl_set_remote_addr, sizeof(struct ifvxlancmd),
454 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
457 [VXLAN_CMD_SET_LOCAL_PORT] =
458 { vxlan_ctrl_set_local_port, sizeof(struct ifvxlancmd),
459 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
462 [VXLAN_CMD_SET_REMOTE_PORT] =
463 { vxlan_ctrl_set_remote_port, sizeof(struct ifvxlancmd),
464 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
467 [VXLAN_CMD_SET_PORT_RANGE] =
468 { vxlan_ctrl_set_port_range, sizeof(struct ifvxlancmd),
469 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
472 [VXLAN_CMD_SET_FTABLE_TIMEOUT] =
473 { vxlan_ctrl_set_ftable_timeout, sizeof(struct ifvxlancmd),
474 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
477 [VXLAN_CMD_SET_FTABLE_MAX] =
478 { vxlan_ctrl_set_ftable_max, sizeof(struct ifvxlancmd),
479 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
482 [VXLAN_CMD_SET_MULTICAST_IF] =
483 { vxlan_ctrl_set_multicast_if, sizeof(struct ifvxlancmd),
484 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
487 [VXLAN_CMD_SET_TTL] =
488 { vxlan_ctrl_set_ttl, sizeof(struct ifvxlancmd),
489 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
492 [VXLAN_CMD_SET_LEARN] =
493 { vxlan_ctrl_set_learn, sizeof(struct ifvxlancmd),
494 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
497 [VXLAN_CMD_FTABLE_ENTRY_ADD] =
498 { vxlan_ctrl_ftable_entry_add, sizeof(struct ifvxlancmd),
499 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
502 [VXLAN_CMD_FTABLE_ENTRY_REM] =
503 { vxlan_ctrl_ftable_entry_rem, sizeof(struct ifvxlancmd),
504 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
508 { vxlan_ctrl_flush, sizeof(struct ifvxlancmd),
509 VXLAN_CTRL_FLAG_COPYIN | VXLAN_CTRL_FLAG_SUSER,
513 static const int vxlan_control_table_size = nitems(vxlan_control_table);
516 vxlan_ftable_addr_cmp(const uint8_t *a, const uint8_t *b)
520 for (i = 0, d = 0; i < ETHER_ADDR_LEN && d == 0; i++)
521 d = ((int)a[i]) - ((int)b[i]);
527 vxlan_ftable_init(struct vxlan_softc *sc)
531 sc->vxl_ftable = malloc(sizeof(struct vxlan_ftable_head) *
532 VXLAN_SC_FTABLE_SIZE, M_VXLAN, M_ZERO | M_WAITOK);
534 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++)
535 LIST_INIT(&sc->vxl_ftable[i]);
536 sc->vxl_ftable_hash_key = arc4random();
540 vxlan_ftable_fini(struct vxlan_softc *sc)
544 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
545 KASSERT(LIST_EMPTY(&sc->vxl_ftable[i]),
546 ("%s: vxlan %p ftable[%d] not empty", __func__, sc, i));
548 MPASS(sc->vxl_ftable_cnt == 0);
550 free(sc->vxl_ftable, M_VXLAN);
551 sc->vxl_ftable = NULL;
555 vxlan_ftable_flush(struct vxlan_softc *sc, int all)
557 struct vxlan_ftable_entry *fe, *tfe;
560 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
561 LIST_FOREACH_SAFE(fe, &sc->vxl_ftable[i], vxlfe_hash, tfe) {
562 if (all || VXLAN_FE_IS_DYNAMIC(fe))
563 vxlan_ftable_entry_destroy(sc, fe);
569 vxlan_ftable_expire(struct vxlan_softc *sc)
571 struct vxlan_ftable_entry *fe, *tfe;
574 VXLAN_LOCK_WASSERT(sc);
576 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
577 LIST_FOREACH_SAFE(fe, &sc->vxl_ftable[i], vxlfe_hash, tfe) {
578 if (VXLAN_FE_IS_DYNAMIC(fe) &&
579 time_uptime >= fe->vxlfe_expire)
580 vxlan_ftable_entry_destroy(sc, fe);
586 vxlan_ftable_update_locked(struct vxlan_softc *sc,
587 const union vxlan_sockaddr *vxlsa, const uint8_t *mac,
588 struct rm_priotracker *tracker)
590 struct vxlan_ftable_entry *fe;
593 VXLAN_LOCK_ASSERT(sc);
597 * A forwarding entry for this MAC address might already exist. If
598 * so, update it, otherwise create a new one. We may have to upgrade
599 * the lock if we have to change or create an entry.
601 fe = vxlan_ftable_entry_lookup(sc, mac);
603 fe->vxlfe_expire = time_uptime + sc->vxl_ftable_timeout;
605 if (!VXLAN_FE_IS_DYNAMIC(fe) ||
606 vxlan_sockaddr_in_equal(&fe->vxlfe_raddr, &vxlsa->sa))
608 if (!VXLAN_LOCK_WOWNED(sc)) {
609 VXLAN_RUNLOCK(sc, tracker);
611 sc->vxl_stats.ftable_lock_upgrade_failed++;
614 vxlan_sockaddr_in_copy(&fe->vxlfe_raddr, &vxlsa->sa);
618 if (!VXLAN_LOCK_WOWNED(sc)) {
619 VXLAN_RUNLOCK(sc, tracker);
621 sc->vxl_stats.ftable_lock_upgrade_failed++;
625 if (sc->vxl_ftable_cnt >= sc->vxl_ftable_max) {
626 sc->vxl_stats.ftable_nospace++;
630 fe = vxlan_ftable_entry_alloc();
634 vxlan_ftable_entry_init(sc, fe, mac, &vxlsa->sa, VXLAN_FE_FLAG_DYNAMIC);
636 /* The prior lookup failed, so the insert should not. */
637 error = vxlan_ftable_entry_insert(sc, fe);
644 vxlan_ftable_learn(struct vxlan_softc *sc, const struct sockaddr *sa,
647 struct rm_priotracker tracker;
648 union vxlan_sockaddr vxlsa;
652 * The source port may be randomly selected by the remote host, so
653 * use the port of the default destination address.
655 vxlan_sockaddr_copy(&vxlsa, sa);
656 vxlsa.in4.sin_port = sc->vxl_dst_addr.in4.sin_port;
658 if (VXLAN_SOCKADDR_IS_IPV6(&vxlsa)) {
659 error = vxlan_sockaddr_in6_embedscope(&vxlsa);
664 VXLAN_RLOCK(sc, &tracker);
665 error = vxlan_ftable_update_locked(sc, &vxlsa, mac, &tracker);
666 VXLAN_UNLOCK(sc, &tracker);
672 vxlan_ftable_sysctl_dump(SYSCTL_HANDLER_ARGS)
674 struct rm_priotracker tracker;
676 struct vxlan_softc *sc;
677 struct vxlan_ftable_entry *fe;
682 * This is mostly intended for debugging during development. It is
683 * not practical to dump an entire large table this way.
687 size = PAGE_SIZE; /* Calculate later. */
689 sbuf_new(&sb, NULL, size, SBUF_FIXEDLEN);
690 sbuf_putc(&sb, '\n');
692 VXLAN_RLOCK(sc, &tracker);
693 for (i = 0; i < VXLAN_SC_FTABLE_SIZE; i++) {
694 LIST_FOREACH(fe, &sc->vxl_ftable[i], vxlfe_hash) {
695 if (sbuf_error(&sb) != 0)
697 vxlan_ftable_entry_dump(fe, &sb);
700 VXLAN_RUNLOCK(sc, &tracker);
702 if (sbuf_len(&sb) == 1)
706 error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
712 static struct vxlan_ftable_entry *
713 vxlan_ftable_entry_alloc(void)
715 struct vxlan_ftable_entry *fe;
717 fe = malloc(sizeof(*fe), M_VXLAN, M_ZERO | M_NOWAIT);
723 vxlan_ftable_entry_free(struct vxlan_ftable_entry *fe)
730 vxlan_ftable_entry_init(struct vxlan_softc *sc, struct vxlan_ftable_entry *fe,
731 const uint8_t *mac, const struct sockaddr *sa, uint32_t flags)
734 fe->vxlfe_flags = flags;
735 fe->vxlfe_expire = time_uptime + sc->vxl_ftable_timeout;
736 memcpy(fe->vxlfe_mac, mac, ETHER_ADDR_LEN);
737 vxlan_sockaddr_copy(&fe->vxlfe_raddr, sa);
741 vxlan_ftable_entry_destroy(struct vxlan_softc *sc,
742 struct vxlan_ftable_entry *fe)
745 sc->vxl_ftable_cnt--;
746 LIST_REMOVE(fe, vxlfe_hash);
747 vxlan_ftable_entry_free(fe);
751 vxlan_ftable_entry_insert(struct vxlan_softc *sc,
752 struct vxlan_ftable_entry *fe)
754 struct vxlan_ftable_entry *lfe;
758 VXLAN_LOCK_WASSERT(sc);
759 hash = VXLAN_SC_FTABLE_HASH(sc, fe->vxlfe_mac);
761 lfe = LIST_FIRST(&sc->vxl_ftable[hash]);
763 LIST_INSERT_HEAD(&sc->vxl_ftable[hash], fe, vxlfe_hash);
768 dir = vxlan_ftable_addr_cmp(fe->vxlfe_mac, lfe->vxlfe_mac);
772 LIST_INSERT_BEFORE(lfe, fe, vxlfe_hash);
774 } else if (LIST_NEXT(lfe, vxlfe_hash) == NULL) {
775 LIST_INSERT_AFTER(lfe, fe, vxlfe_hash);
778 lfe = LIST_NEXT(lfe, vxlfe_hash);
779 } while (lfe != NULL);
782 sc->vxl_ftable_cnt++;
787 static struct vxlan_ftable_entry *
788 vxlan_ftable_entry_lookup(struct vxlan_softc *sc, const uint8_t *mac)
790 struct vxlan_ftable_entry *fe;
794 VXLAN_LOCK_ASSERT(sc);
795 hash = VXLAN_SC_FTABLE_HASH(sc, mac);
797 LIST_FOREACH(fe, &sc->vxl_ftable[hash], vxlfe_hash) {
798 dir = vxlan_ftable_addr_cmp(mac, fe->vxlfe_mac);
809 vxlan_ftable_entry_dump(struct vxlan_ftable_entry *fe, struct sbuf *sb)
812 const union vxlan_sockaddr *sa;
814 int i, len, af, width;
816 sa = &fe->vxlfe_raddr;
817 af = sa->sa.sa_family;
820 sbuf_printf(sb, "%c 0x%02X ", VXLAN_FE_IS_DYNAMIC(fe) ? 'D' : 'S',
823 for (i = 0; i < ETHER_ADDR_LEN - 1; i++)
824 sbuf_printf(sb, "%02X:", fe->vxlfe_mac[i]);
825 sbuf_printf(sb, "%02X ", fe->vxlfe_mac[i]);
828 addr = &sa->in4.sin_addr;
829 width = INET_ADDRSTRLEN - 1;
831 addr = &sa->in6.sin6_addr;
832 width = INET6_ADDRSTRLEN - 1;
834 inet_ntop(af, addr, buf, sizeof(buf));
835 sbuf_printf(sb, "%*s ", width, buf);
837 sbuf_printf(sb, "%08jd", (intmax_t)fe->vxlfe_expire);
841 /* Truncate a partial line. */
842 if (sbuf_error(sb) != 0)
843 sbuf_setpos(sb, len);
846 static struct vxlan_socket *
847 vxlan_socket_alloc(const union vxlan_sockaddr *sa)
849 struct vxlan_socket *vso;
852 vso = malloc(sizeof(*vso), M_VXLAN, M_WAITOK | M_ZERO);
853 rm_init(&vso->vxlso_lock, "vxlansorm");
854 refcount_init(&vso->vxlso_refcnt, 0);
855 for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++)
856 LIST_INIT(&vso->vxlso_vni_hash[i]);
857 vso->vxlso_laddr = *sa;
863 vxlan_socket_destroy(struct vxlan_socket *vso)
868 struct vxlan_socket_mc_info *mc;
870 for (i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
871 mc = &vso->vxlso_mc[i];
872 KASSERT(mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC,
873 ("%s: socket %p mc[%d] still has address",
877 for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++) {
878 KASSERT(LIST_EMPTY(&vso->vxlso_vni_hash[i]),
879 ("%s: socket %p vni_hash[%d] not empty",
883 so = vso->vxlso_sock;
885 vso->vxlso_sock = NULL;
889 rm_destroy(&vso->vxlso_lock);
894 vxlan_socket_release(struct vxlan_socket *vso)
899 destroy = VXLAN_SO_RELEASE(vso);
901 LIST_REMOVE(vso, vxlso_entry);
905 vxlan_socket_destroy(vso);
908 static struct vxlan_socket *
909 vxlan_socket_lookup(union vxlan_sockaddr *vxlsa)
911 struct vxlan_socket *vso;
914 LIST_FOREACH(vso, &vxlan_socket_list, vxlso_entry) {
915 if (vxlan_sockaddr_cmp(&vso->vxlso_laddr, &vxlsa->sa) == 0) {
916 VXLAN_SO_ACQUIRE(vso);
926 vxlan_socket_insert(struct vxlan_socket *vso)
930 VXLAN_SO_ACQUIRE(vso);
931 LIST_INSERT_HEAD(&vxlan_socket_list, vso, vxlso_entry);
936 vxlan_socket_init(struct vxlan_socket *vso, struct ifnet *ifp)
943 error = socreate(vso->vxlso_laddr.sa.sa_family, &vso->vxlso_sock,
944 SOCK_DGRAM, IPPROTO_UDP, td->td_ucred, td);
946 if_printf(ifp, "cannot create socket: %d\n", error);
950 error = udp_set_kernel_tunneling(vso->vxlso_sock,
951 vxlan_rcv_udp_packet, NULL, vso);
953 if_printf(ifp, "cannot set tunneling function: %d\n", error);
957 if (vxlan_reuse_port != 0) {
961 bzero(&sopt, sizeof(sopt));
962 sopt.sopt_dir = SOPT_SET;
963 sopt.sopt_level = IPPROTO_IP;
964 sopt.sopt_name = SO_REUSEPORT;
965 sopt.sopt_val = &val;
966 sopt.sopt_valsize = sizeof(val);
967 error = sosetopt(vso->vxlso_sock, &sopt);
970 "cannot set REUSEADDR socket opt: %d\n", error);
979 vxlan_socket_bind(struct vxlan_socket *vso, struct ifnet *ifp)
981 union vxlan_sockaddr laddr;
986 laddr = vso->vxlso_laddr;
988 error = sobind(vso->vxlso_sock, &laddr.sa, td);
990 if (error != EADDRINUSE)
991 if_printf(ifp, "cannot bind socket: %d\n", error);
999 vxlan_socket_create(struct ifnet *ifp, int multicast,
1000 const union vxlan_sockaddr *saddr, struct vxlan_socket **vsop)
1002 union vxlan_sockaddr laddr;
1003 struct vxlan_socket *vso;
1009 * If this socket will be multicast, then only the local port
1010 * must be specified when binding.
1012 if (multicast != 0) {
1013 if (VXLAN_SOCKADDR_IS_IPV4(&laddr))
1014 laddr.in4.sin_addr.s_addr = INADDR_ANY;
1017 laddr.in6.sin6_addr = in6addr_any;
1021 vso = vxlan_socket_alloc(&laddr);
1025 error = vxlan_socket_init(vso, ifp);
1029 error = vxlan_socket_bind(vso, ifp);
1034 * There is a small window between the bind completing and
1035 * inserting the socket, so that a concurrent create may fail.
1036 * Let's not worry about that for now.
1038 vxlan_socket_insert(vso);
1044 vxlan_socket_destroy(vso);
1050 vxlan_socket_ifdetach(struct vxlan_socket *vso, struct ifnet *ifp,
1051 struct vxlan_softc_head *list)
1053 struct rm_priotracker tracker;
1054 struct vxlan_softc *sc;
1057 VXLAN_SO_RLOCK(vso, &tracker);
1058 for (i = 0; i < VXLAN_SO_VNI_HASH_SIZE; i++) {
1059 LIST_FOREACH(sc, &vso->vxlso_vni_hash[i], vxl_entry)
1060 vxlan_ifdetach(sc, ifp, list);
1062 VXLAN_SO_RUNLOCK(vso, &tracker);
1065 static struct vxlan_socket *
1066 vxlan_socket_mc_lookup(const union vxlan_sockaddr *vxlsa)
1068 union vxlan_sockaddr laddr;
1069 struct vxlan_socket *vso;
1073 if (VXLAN_SOCKADDR_IS_IPV4(&laddr))
1074 laddr.in4.sin_addr.s_addr = INADDR_ANY;
1077 laddr.in6.sin6_addr = in6addr_any;
1080 vso = vxlan_socket_lookup(&laddr);
1086 vxlan_sockaddr_mc_info_match(const struct vxlan_socket_mc_info *mc,
1087 const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1091 if (!vxlan_sockaddr_in_any(local) &&
1092 !vxlan_sockaddr_in_equal(&mc->vxlsomc_saddr, &local->sa))
1094 if (!vxlan_sockaddr_in_equal(&mc->vxlsomc_gaddr, &group->sa))
1096 if (ifidx != 0 && ifidx != mc->vxlsomc_ifidx)
1103 vxlan_socket_mc_join_group(struct vxlan_socket *vso,
1104 const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1105 int *ifidx, union vxlan_sockaddr *source)
1107 struct sockopt sopt;
1112 if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1113 struct ip_mreq mreq;
1115 mreq.imr_multiaddr = group->in4.sin_addr;
1116 mreq.imr_interface = local->in4.sin_addr;
1118 bzero(&sopt, sizeof(sopt));
1119 sopt.sopt_dir = SOPT_SET;
1120 sopt.sopt_level = IPPROTO_IP;
1121 sopt.sopt_name = IP_ADD_MEMBERSHIP;
1122 sopt.sopt_val = &mreq;
1123 sopt.sopt_valsize = sizeof(mreq);
1124 error = sosetopt(vso->vxlso_sock, &sopt);
1129 * BMV: Ideally, there would be a formal way for us to get
1130 * the local interface that was selected based on the
1131 * imr_interface address. We could then update *ifidx so
1132 * vxlan_sockaddr_mc_info_match() would return a match for
1133 * later creates that explicitly set the multicast interface.
1135 * If we really need to, we can of course look in the INP's
1137 * sotoinpcb(vso->vxlso_sock)->inp_moptions->
1138 * imo_membership[]->inm_ifp
1139 * similarly to imo_match_group().
1141 source->in4.sin_addr = local->in4.sin_addr;
1143 } else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1144 struct ipv6_mreq mreq;
1146 mreq.ipv6mr_multiaddr = group->in6.sin6_addr;
1147 mreq.ipv6mr_interface = *ifidx;
1149 bzero(&sopt, sizeof(sopt));
1150 sopt.sopt_dir = SOPT_SET;
1151 sopt.sopt_level = IPPROTO_IPV6;
1152 sopt.sopt_name = IPV6_JOIN_GROUP;
1153 sopt.sopt_val = &mreq;
1154 sopt.sopt_valsize = sizeof(mreq);
1155 error = sosetopt(vso->vxlso_sock, &sopt);
1160 * BMV: As with IPv4, we would really like to know what
1161 * interface in6p_lookup_mcast_ifp() selected.
1164 error = EAFNOSUPPORT;
1170 vxlan_socket_mc_leave_group(struct vxlan_socket *vso,
1171 const union vxlan_sockaddr *group, const union vxlan_sockaddr *source,
1174 struct sockopt sopt;
1177 bzero(&sopt, sizeof(sopt));
1178 sopt.sopt_dir = SOPT_SET;
1180 if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1181 struct ip_mreq mreq;
1183 mreq.imr_multiaddr = group->in4.sin_addr;
1184 mreq.imr_interface = source->in4.sin_addr;
1186 sopt.sopt_level = IPPROTO_IP;
1187 sopt.sopt_name = IP_DROP_MEMBERSHIP;
1188 sopt.sopt_val = &mreq;
1189 sopt.sopt_valsize = sizeof(mreq);
1190 error = sosetopt(vso->vxlso_sock, &sopt);
1192 } else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1193 struct ipv6_mreq mreq;
1195 mreq.ipv6mr_multiaddr = group->in6.sin6_addr;
1196 mreq.ipv6mr_interface = ifidx;
1198 sopt.sopt_level = IPPROTO_IPV6;
1199 sopt.sopt_name = IPV6_LEAVE_GROUP;
1200 sopt.sopt_val = &mreq;
1201 sopt.sopt_valsize = sizeof(mreq);
1202 error = sosetopt(vso->vxlso_sock, &sopt);
1205 error = EAFNOSUPPORT;
1211 vxlan_socket_mc_add_group(struct vxlan_socket *vso,
1212 const union vxlan_sockaddr *group, const union vxlan_sockaddr *local,
1213 int ifidx, int *idx)
1215 union vxlan_sockaddr source;
1216 struct vxlan_socket_mc_info *mc;
1217 int i, empty, error;
1220 * Within a socket, the same multicast group may be used by multiple
1221 * interfaces, each with a different network identifier. But a socket
1222 * may only join a multicast group once, so keep track of the users
1226 VXLAN_SO_WLOCK(vso);
1227 for (empty = 0, i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
1228 mc = &vso->vxlso_mc[i];
1230 if (mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC) {
1235 if (vxlan_sockaddr_mc_info_match(mc, group, local, ifidx))
1238 VXLAN_SO_WUNLOCK(vso);
1243 error = vxlan_socket_mc_join_group(vso, group, local, &ifidx, &source);
1247 VXLAN_SO_WLOCK(vso);
1248 for (i = 0; i < VXLAN_SO_MC_MAX_GROUPS; i++) {
1249 mc = &vso->vxlso_mc[i];
1251 if (mc->vxlsomc_gaddr.sa.sa_family == AF_UNSPEC) {
1252 vxlan_sockaddr_copy(&mc->vxlsomc_gaddr, &group->sa);
1253 vxlan_sockaddr_copy(&mc->vxlsomc_saddr, &source.sa);
1254 mc->vxlsomc_ifidx = ifidx;
1258 VXLAN_SO_WUNLOCK(vso);
1260 error = vxlan_socket_mc_leave_group(vso, group, &source, ifidx);
1266 mc->vxlsomc_users++;
1267 VXLAN_SO_WUNLOCK(vso);
1275 vxlan_socket_mc_release_group_by_idx(struct vxlan_socket *vso, int idx)
1277 union vxlan_sockaddr group, source;
1278 struct vxlan_socket_mc_info *mc;
1281 KASSERT(idx >= 0 && idx < VXLAN_SO_MC_MAX_GROUPS,
1282 ("%s: vso %p idx %d out of bounds", __func__, vso, idx));
1285 mc = &vso->vxlso_mc[idx];
1287 VXLAN_SO_WLOCK(vso);
1288 mc->vxlsomc_users--;
1289 if (mc->vxlsomc_users == 0) {
1290 group = mc->vxlsomc_gaddr;
1291 source = mc->vxlsomc_saddr;
1292 ifidx = mc->vxlsomc_ifidx;
1293 bzero(mc, sizeof(*mc));
1296 VXLAN_SO_WUNLOCK(vso);
1300 * Our socket's membership in this group may have already
1301 * been removed if we joined through an interface that's
1304 vxlan_socket_mc_leave_group(vso, &group, &source, ifidx);
1308 static struct vxlan_softc *
1309 vxlan_socket_lookup_softc_locked(struct vxlan_socket *vso, uint32_t vni)
1311 struct vxlan_softc *sc;
1314 VXLAN_SO_LOCK_ASSERT(vso);
1315 hash = VXLAN_SO_VNI_HASH(vni);
1317 LIST_FOREACH(sc, &vso->vxlso_vni_hash[hash], vxl_entry) {
1318 if (sc->vxl_vni == vni) {
1327 static struct vxlan_softc *
1328 vxlan_socket_lookup_softc(struct vxlan_socket *vso, uint32_t vni)
1330 struct rm_priotracker tracker;
1331 struct vxlan_softc *sc;
1333 VXLAN_SO_RLOCK(vso, &tracker);
1334 sc = vxlan_socket_lookup_softc_locked(vso, vni);
1335 VXLAN_SO_RUNLOCK(vso, &tracker);
1341 vxlan_socket_insert_softc(struct vxlan_socket *vso, struct vxlan_softc *sc)
1343 struct vxlan_softc *tsc;
1347 hash = VXLAN_SO_VNI_HASH(vni);
1349 VXLAN_SO_WLOCK(vso);
1350 tsc = vxlan_socket_lookup_softc_locked(vso, vni);
1352 VXLAN_SO_WUNLOCK(vso);
1358 LIST_INSERT_HEAD(&vso->vxlso_vni_hash[hash], sc, vxl_entry);
1359 VXLAN_SO_WUNLOCK(vso);
1365 vxlan_socket_remove_softc(struct vxlan_socket *vso, struct vxlan_softc *sc)
1368 VXLAN_SO_WLOCK(vso);
1369 LIST_REMOVE(sc, vxl_entry);
1370 VXLAN_SO_WUNLOCK(vso);
1375 static struct ifnet *
1376 vxlan_multicast_if_ref(struct vxlan_softc *sc, int ipv4)
1380 VXLAN_LOCK_ASSERT(sc);
1382 if (ipv4 && sc->vxl_im4o != NULL)
1383 ifp = sc->vxl_im4o->imo_multicast_ifp;
1384 else if (!ipv4 && sc->vxl_im6o != NULL)
1385 ifp = sc->vxl_im6o->im6o_multicast_ifp;
1396 vxlan_free_multicast(struct vxlan_softc *sc)
1399 if (sc->vxl_mc_ifp != NULL) {
1400 if_rele(sc->vxl_mc_ifp);
1401 sc->vxl_mc_ifp = NULL;
1402 sc->vxl_mc_ifindex = 0;
1405 if (sc->vxl_im4o != NULL) {
1406 free(sc->vxl_im4o, M_VXLAN);
1407 sc->vxl_im4o = NULL;
1410 if (sc->vxl_im6o != NULL) {
1411 free(sc->vxl_im6o, M_VXLAN);
1412 sc->vxl_im6o = NULL;
1417 vxlan_setup_multicast_interface(struct vxlan_softc *sc)
1421 ifp = ifunit_ref(sc->vxl_mc_ifname);
1423 if_printf(sc->vxl_ifp, "multicast interface %s does "
1424 "not exist\n", sc->vxl_mc_ifname);
1428 if ((ifp->if_flags & IFF_MULTICAST) == 0) {
1429 if_printf(sc->vxl_ifp, "interface %s does not support "
1430 "multicast\n", sc->vxl_mc_ifname);
1435 sc->vxl_mc_ifp = ifp;
1436 sc->vxl_mc_ifindex = ifp->if_index;
1442 vxlan_setup_multicast(struct vxlan_softc *sc)
1444 const union vxlan_sockaddr *group;
1447 group = &sc->vxl_dst_addr;
1450 if (sc->vxl_mc_ifname[0] != '\0') {
1451 error = vxlan_setup_multicast_interface(sc);
1457 * Initialize an multicast options structure that is sufficiently
1458 * populated for use in the respective IP output routine. This
1459 * structure is typically stored in the socket, but our sockets
1460 * may be shared among multiple interfaces.
1462 if (VXLAN_SOCKADDR_IS_IPV4(group)) {
1463 sc->vxl_im4o = malloc(sizeof(struct ip_moptions), M_VXLAN,
1465 sc->vxl_im4o->imo_multicast_ifp = sc->vxl_mc_ifp;
1466 sc->vxl_im4o->imo_multicast_ttl = sc->vxl_ttl;
1467 sc->vxl_im4o->imo_multicast_vif = -1;
1468 } else if (VXLAN_SOCKADDR_IS_IPV6(group)) {
1469 sc->vxl_im6o = malloc(sizeof(struct ip6_moptions), M_VXLAN,
1471 sc->vxl_im6o->im6o_multicast_ifp = sc->vxl_mc_ifp;
1472 sc->vxl_im6o->im6o_multicast_hlim = sc->vxl_ttl;
1479 vxlan_setup_socket(struct vxlan_softc *sc)
1481 struct vxlan_socket *vso;
1483 union vxlan_sockaddr *saddr, *daddr;
1484 int multicast, error;
1488 saddr = &sc->vxl_src_addr;
1489 daddr = &sc->vxl_dst_addr;
1491 multicast = vxlan_sockaddr_in_multicast(daddr);
1492 MPASS(multicast != -1);
1493 sc->vxl_vso_mc_index = -1;
1496 * Try to create the socket. If that fails, attempt to use an
1499 error = vxlan_socket_create(ifp, multicast, saddr, &vso);
1502 vso = vxlan_socket_mc_lookup(saddr);
1504 vso = vxlan_socket_lookup(saddr);
1507 if_printf(ifp, "cannot create socket (error: %d), "
1508 "and no existing socket found\n", error);
1513 if (multicast != 0) {
1514 error = vxlan_setup_multicast(sc);
1518 error = vxlan_socket_mc_add_group(vso, daddr, saddr,
1519 sc->vxl_mc_ifindex, &sc->vxl_vso_mc_index);
1525 error = vxlan_socket_insert_softc(vso, sc);
1527 sc->vxl_sock = NULL;
1528 if_printf(ifp, "network identifier %d already exists in "
1529 "this socket\n", sc->vxl_vni);
1537 if (sc->vxl_vso_mc_index != -1) {
1538 vxlan_socket_mc_release_group_by_idx(vso,
1539 sc->vxl_vso_mc_index);
1540 sc->vxl_vso_mc_index = -1;
1543 vxlan_free_multicast(sc);
1544 vxlan_socket_release(vso);
1551 vxlan_setup_interface(struct vxlan_softc *sc)
1556 ifp->if_hdrlen = ETHER_HDR_LEN + sizeof(struct vxlanudphdr);
1558 if (VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_dst_addr) != 0)
1559 ifp->if_hdrlen += sizeof(struct ip);
1560 else if (VXLAN_SOCKADDR_IS_IPV6(&sc->vxl_dst_addr) != 0)
1561 ifp->if_hdrlen += sizeof(struct ip6_hdr);
1565 vxlan_valid_init_config(struct vxlan_softc *sc)
1569 if (vxlan_check_vni(sc->vxl_vni) != 0) {
1570 reason = "invalid virtual network identifier specified";
1574 if (vxlan_sockaddr_supported(&sc->vxl_src_addr, 1) == 0) {
1575 reason = "source address type is not supported";
1579 if (vxlan_sockaddr_supported(&sc->vxl_dst_addr, 0) == 0) {
1580 reason = "destination address type is not supported";
1584 if (vxlan_sockaddr_in_any(&sc->vxl_dst_addr) != 0) {
1585 reason = "no valid destination address specified";
1589 if (vxlan_sockaddr_in_multicast(&sc->vxl_dst_addr) == 0 &&
1590 sc->vxl_mc_ifname[0] != '\0') {
1591 reason = "can only specify interface with a group address";
1595 if (vxlan_sockaddr_in_any(&sc->vxl_src_addr) == 0) {
1596 if (VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_src_addr) ^
1597 VXLAN_SOCKADDR_IS_IPV4(&sc->vxl_dst_addr)) {
1598 reason = "source and destination address must both "
1599 "be either IPv4 or IPv6";
1604 if (sc->vxl_src_addr.in4.sin_port == 0) {
1605 reason = "local port not specified";
1609 if (sc->vxl_dst_addr.in4.sin_port == 0) {
1610 reason = "remote port not specified";
1617 if_printf(sc->vxl_ifp, "cannot initialize interface: %s\n", reason);
1622 vxlan_init_wait(struct vxlan_softc *sc)
1625 VXLAN_LOCK_WASSERT(sc);
1626 while (sc->vxl_flags & VXLAN_FLAG_INIT)
1627 rm_sleep(sc, &sc->vxl_lock, 0, "vxlint", hz);
1631 vxlan_init_complete(struct vxlan_softc *sc)
1635 sc->vxl_flags &= ~VXLAN_FLAG_INIT;
1641 vxlan_init(void *xsc)
1643 static const uint8_t empty_mac[ETHER_ADDR_LEN];
1644 struct vxlan_softc *sc;
1651 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1655 sc->vxl_flags |= VXLAN_FLAG_INIT;
1658 if (vxlan_valid_init_config(sc) != 0)
1661 vxlan_setup_interface(sc);
1663 if (vxlan_setup_socket(sc) != 0)
1666 /* Initialize the default forwarding entry. */
1667 vxlan_ftable_entry_init(sc, &sc->vxl_default_fe, empty_mac,
1668 &sc->vxl_dst_addr.sa, VXLAN_FE_FLAG_STATIC);
1671 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1672 callout_reset(&sc->vxl_callout, vxlan_ftable_prune_period * hz,
1676 if_link_state_change(ifp, LINK_STATE_UP);
1678 vxlan_init_complete(sc);
1682 vxlan_release(struct vxlan_softc *sc)
1686 * The softc may be destroyed as soon as we release our reference,
1687 * so we cannot serialize the wakeup with the softc lock. We use a
1688 * timeout in our sleeps so a missed wakeup is unfortunate but not
1691 if (VXLAN_RELEASE(sc) != 0)
1696 vxlan_teardown_wait(struct vxlan_softc *sc)
1699 VXLAN_LOCK_WASSERT(sc);
1700 while (sc->vxl_flags & VXLAN_FLAG_TEARDOWN)
1701 rm_sleep(sc, &sc->vxl_lock, 0, "vxltrn", hz);
1705 vxlan_teardown_complete(struct vxlan_softc *sc)
1709 sc->vxl_flags &= ~VXLAN_FLAG_TEARDOWN;
1715 vxlan_teardown_locked(struct vxlan_softc *sc)
1718 struct vxlan_socket *vso;
1722 VXLAN_LOCK_WASSERT(sc);
1723 MPASS(sc->vxl_flags & VXLAN_FLAG_TEARDOWN);
1725 ifp->if_flags &= ~IFF_UP;
1726 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1727 callout_stop(&sc->vxl_callout);
1729 sc->vxl_sock = NULL;
1732 if_link_state_change(ifp, LINK_STATE_DOWN);
1735 vxlan_socket_remove_softc(vso, sc);
1737 if (sc->vxl_vso_mc_index != -1) {
1738 vxlan_socket_mc_release_group_by_idx(vso,
1739 sc->vxl_vso_mc_index);
1740 sc->vxl_vso_mc_index = -1;
1745 while (sc->vxl_refcnt != 0)
1746 rm_sleep(sc, &sc->vxl_lock, 0, "vxldrn", hz);
1749 callout_drain(&sc->vxl_callout);
1751 vxlan_free_multicast(sc);
1753 vxlan_socket_release(vso);
1755 vxlan_teardown_complete(sc);
1759 vxlan_teardown(struct vxlan_softc *sc)
1763 if (sc->vxl_flags & VXLAN_FLAG_TEARDOWN) {
1764 vxlan_teardown_wait(sc);
1769 sc->vxl_flags |= VXLAN_FLAG_TEARDOWN;
1770 vxlan_teardown_locked(sc);
1774 vxlan_ifdetach(struct vxlan_softc *sc, struct ifnet *ifp,
1775 struct vxlan_softc_head *list)
1780 if (sc->vxl_mc_ifp != ifp)
1782 if (sc->vxl_flags & VXLAN_FLAG_TEARDOWN)
1785 sc->vxl_flags |= VXLAN_FLAG_TEARDOWN;
1786 LIST_INSERT_HEAD(list, sc, vxl_ifdetach_list);
1793 vxlan_timer(void *xsc)
1795 struct vxlan_softc *sc;
1798 VXLAN_LOCK_WASSERT(sc);
1800 vxlan_ftable_expire(sc);
1801 callout_schedule(&sc->vxl_callout, vxlan_ftable_prune_period * hz);
1805 vxlan_ioctl_ifflags(struct vxlan_softc *sc)
1811 if (ifp->if_flags & IFF_UP) {
1812 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1815 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1823 vxlan_ctrl_get_config(struct vxlan_softc *sc, void *arg)
1825 struct rm_priotracker tracker;
1826 struct ifvxlancfg *cfg;
1829 bzero(cfg, sizeof(*cfg));
1831 VXLAN_RLOCK(sc, &tracker);
1832 cfg->vxlc_vni = sc->vxl_vni;
1833 memcpy(&cfg->vxlc_local_sa, &sc->vxl_src_addr,
1834 sizeof(union vxlan_sockaddr));
1835 memcpy(&cfg->vxlc_remote_sa, &sc->vxl_dst_addr,
1836 sizeof(union vxlan_sockaddr));
1837 cfg->vxlc_mc_ifindex = sc->vxl_mc_ifindex;
1838 cfg->vxlc_ftable_cnt = sc->vxl_ftable_cnt;
1839 cfg->vxlc_ftable_max = sc->vxl_ftable_max;
1840 cfg->vxlc_ftable_timeout = sc->vxl_ftable_timeout;
1841 cfg->vxlc_port_min = sc->vxl_min_port;
1842 cfg->vxlc_port_max = sc->vxl_max_port;
1843 cfg->vxlc_learn = (sc->vxl_flags & VXLAN_FLAG_LEARN) != 0;
1844 cfg->vxlc_ttl = sc->vxl_ttl;
1845 VXLAN_RUNLOCK(sc, &tracker);
1848 if (VXLAN_SOCKADDR_IS_IPV6(&cfg->vxlc_local_sa))
1849 sa6_recoverscope(&cfg->vxlc_local_sa.in6);
1850 if (VXLAN_SOCKADDR_IS_IPV6(&cfg->vxlc_remote_sa))
1851 sa6_recoverscope(&cfg->vxlc_remote_sa.in6);
1858 vxlan_ctrl_set_vni(struct vxlan_softc *sc, void *arg)
1860 struct ifvxlancmd *cmd;
1865 if (vxlan_check_vni(cmd->vxlcmd_vni) != 0)
1869 if (vxlan_can_change_config(sc)) {
1870 sc->vxl_vni = cmd->vxlcmd_vni;
1880 vxlan_ctrl_set_local_addr(struct vxlan_softc *sc, void *arg)
1882 struct ifvxlancmd *cmd;
1883 union vxlan_sockaddr *vxlsa;
1887 vxlsa = &cmd->vxlcmd_sa;
1889 if (!VXLAN_SOCKADDR_IS_IPV46(vxlsa))
1891 if (vxlan_sockaddr_in_multicast(vxlsa) != 0)
1893 if (VXLAN_SOCKADDR_IS_IPV6(vxlsa)) {
1894 error = vxlan_sockaddr_in6_embedscope(vxlsa);
1900 if (vxlan_can_change_config(sc)) {
1901 vxlan_sockaddr_in_copy(&sc->vxl_src_addr, &vxlsa->sa);
1911 vxlan_ctrl_set_remote_addr(struct vxlan_softc *sc, void *arg)
1913 struct ifvxlancmd *cmd;
1914 union vxlan_sockaddr *vxlsa;
1918 vxlsa = &cmd->vxlcmd_sa;
1920 if (!VXLAN_SOCKADDR_IS_IPV46(vxlsa))
1922 if (VXLAN_SOCKADDR_IS_IPV6(vxlsa)) {
1923 error = vxlan_sockaddr_in6_embedscope(vxlsa);
1929 if (vxlan_can_change_config(sc)) {
1930 vxlan_sockaddr_in_copy(&sc->vxl_dst_addr, &vxlsa->sa);
1940 vxlan_ctrl_set_local_port(struct vxlan_softc *sc, void *arg)
1942 struct ifvxlancmd *cmd;
1947 if (cmd->vxlcmd_port == 0)
1951 if (vxlan_can_change_config(sc)) {
1952 sc->vxl_src_addr.in4.sin_port = htons(cmd->vxlcmd_port);
1962 vxlan_ctrl_set_remote_port(struct vxlan_softc *sc, void *arg)
1964 struct ifvxlancmd *cmd;
1969 if (cmd->vxlcmd_port == 0)
1973 if (vxlan_can_change_config(sc)) {
1974 sc->vxl_dst_addr.in4.sin_port = htons(cmd->vxlcmd_port);
1984 vxlan_ctrl_set_port_range(struct vxlan_softc *sc, void *arg)
1986 struct ifvxlancmd *cmd;
1991 min = cmd->vxlcmd_port_min;
1992 max = cmd->vxlcmd_port_max;
1998 if (vxlan_can_change_config(sc)) {
1999 sc->vxl_min_port = min;
2000 sc->vxl_max_port = max;
2010 vxlan_ctrl_set_ftable_timeout(struct vxlan_softc *sc, void *arg)
2012 struct ifvxlancmd *cmd;
2018 if (vxlan_check_ftable_timeout(cmd->vxlcmd_ftable_timeout) == 0) {
2019 sc->vxl_ftable_timeout = cmd->vxlcmd_ftable_timeout;
2029 vxlan_ctrl_set_ftable_max(struct vxlan_softc *sc, void *arg)
2031 struct ifvxlancmd *cmd;
2037 if (vxlan_check_ftable_max(cmd->vxlcmd_ftable_max) == 0) {
2038 sc->vxl_ftable_max = cmd->vxlcmd_ftable_max;
2048 vxlan_ctrl_set_multicast_if(struct vxlan_softc * sc, void *arg)
2050 struct ifvxlancmd *cmd;
2056 if (vxlan_can_change_config(sc)) {
2057 strlcpy(sc->vxl_mc_ifname, cmd->vxlcmd_ifname, IFNAMSIZ);
2067 vxlan_ctrl_set_ttl(struct vxlan_softc *sc, void *arg)
2069 struct ifvxlancmd *cmd;
2075 if (vxlan_check_ttl(cmd->vxlcmd_ttl) == 0) {
2076 sc->vxl_ttl = cmd->vxlcmd_ttl;
2077 if (sc->vxl_im4o != NULL)
2078 sc->vxl_im4o->imo_multicast_ttl = sc->vxl_ttl;
2079 if (sc->vxl_im6o != NULL)
2080 sc->vxl_im6o->im6o_multicast_hlim = sc->vxl_ttl;
2090 vxlan_ctrl_set_learn(struct vxlan_softc *sc, void *arg)
2092 struct ifvxlancmd *cmd;
2097 if (cmd->vxlcmd_flags & VXLAN_CMD_FLAG_LEARN)
2098 sc->vxl_flags |= VXLAN_FLAG_LEARN;
2100 sc->vxl_flags &= ~VXLAN_FLAG_LEARN;
2107 vxlan_ctrl_ftable_entry_add(struct vxlan_softc *sc, void *arg)
2109 union vxlan_sockaddr vxlsa;
2110 struct ifvxlancmd *cmd;
2111 struct vxlan_ftable_entry *fe;
2115 vxlsa = cmd->vxlcmd_sa;
2117 if (!VXLAN_SOCKADDR_IS_IPV46(&vxlsa))
2119 if (vxlan_sockaddr_in_any(&vxlsa) != 0)
2121 if (vxlan_sockaddr_in_multicast(&vxlsa) != 0)
2123 /* BMV: We could support both IPv4 and IPv6 later. */
2124 if (vxlsa.sa.sa_family != sc->vxl_dst_addr.sa.sa_family)
2125 return (EAFNOSUPPORT);
2127 if (VXLAN_SOCKADDR_IS_IPV6(&vxlsa)) {
2128 error = vxlan_sockaddr_in6_embedscope(&vxlsa);
2133 fe = vxlan_ftable_entry_alloc();
2137 if (vxlsa.in4.sin_port == 0)
2138 vxlsa.in4.sin_port = sc->vxl_dst_addr.in4.sin_port;
2140 vxlan_ftable_entry_init(sc, fe, cmd->vxlcmd_mac, &vxlsa.sa,
2141 VXLAN_FE_FLAG_STATIC);
2144 error = vxlan_ftable_entry_insert(sc, fe);
2148 vxlan_ftable_entry_free(fe);
2154 vxlan_ctrl_ftable_entry_rem(struct vxlan_softc *sc, void *arg)
2156 struct ifvxlancmd *cmd;
2157 struct vxlan_ftable_entry *fe;
2163 fe = vxlan_ftable_entry_lookup(sc, cmd->vxlcmd_mac);
2165 vxlan_ftable_entry_destroy(sc, fe);
2175 vxlan_ctrl_flush(struct vxlan_softc *sc, void *arg)
2177 struct ifvxlancmd *cmd;
2181 all = cmd->vxlcmd_flags & VXLAN_CMD_FLAG_FLUSH_ALL;
2184 vxlan_ftable_flush(sc, all);
2191 vxlan_ioctl_drvspec(struct vxlan_softc *sc, struct ifdrv *ifd, int get)
2193 const struct vxlan_control *vc;
2195 struct ifvxlancfg cfg;
2196 struct ifvxlancmd cmd;
2200 if (ifd->ifd_cmd >= vxlan_control_table_size)
2203 bzero(&args, sizeof(args));
2204 vc = &vxlan_control_table[ifd->ifd_cmd];
2205 out = (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYOUT) != 0;
2207 if ((get != 0 && out == 0) || (get == 0 && out != 0))
2210 if (vc->vxlc_flags & VXLAN_CTRL_FLAG_SUSER) {
2211 error = priv_check(curthread, PRIV_NET_VXLAN);
2216 if (ifd->ifd_len != vc->vxlc_argsize ||
2217 ifd->ifd_len > sizeof(args))
2220 if (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYIN) {
2221 error = copyin(ifd->ifd_data, &args, ifd->ifd_len);
2226 error = vc->vxlc_func(sc, &args);
2230 if (vc->vxlc_flags & VXLAN_CTRL_FLAG_COPYOUT) {
2231 error = copyout(&args, ifd->ifd_data, ifd->ifd_len);
2240 vxlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2242 struct vxlan_softc *sc;
2248 ifr = (struct ifreq *) data;
2249 ifd = (struct ifdrv *) data;
2259 error = vxlan_ioctl_drvspec(sc, ifd, cmd == SIOCGDRVSPEC);
2263 error = vxlan_ioctl_ifflags(sc);
2268 error = ifmedia_ioctl(ifp, ifr, &sc->vxl_media, cmd);
2272 error = ether_ioctl(ifp, cmd, data);
2279 #if defined(INET) || defined(INET6)
2281 vxlan_pick_source_port(struct vxlan_softc *sc, struct mbuf *m)
2286 range = sc->vxl_max_port - sc->vxl_min_port + 1;
2288 if (M_HASHTYPE_ISHASH(m))
2289 hash = m->m_pkthdr.flowid;
2291 hash = jenkins_hash(m->m_data, ETHER_HDR_LEN,
2292 sc->vxl_port_hash_key);
2294 return (sc->vxl_min_port + (hash % range));
2298 vxlan_encap_header(struct vxlan_softc *sc, struct mbuf *m, int ipoff,
2299 uint16_t srcport, uint16_t dstport)
2301 struct vxlanudphdr *hdr;
2302 struct udphdr *udph;
2303 struct vxlan_header *vxh;
2306 len = m->m_pkthdr.len - ipoff;
2307 MPASS(len >= sizeof(struct vxlanudphdr));
2308 hdr = mtodo(m, ipoff);
2310 udph = &hdr->vxlh_udp;
2311 udph->uh_sport = srcport;
2312 udph->uh_dport = dstport;
2313 udph->uh_ulen = htons(len);
2316 vxh = &hdr->vxlh_hdr;
2317 vxh->vxlh_flags = htonl(VXLAN_HDR_FLAGS_VALID_VNI);
2318 vxh->vxlh_vni = htonl(sc->vxl_vni << VXLAN_HDR_VNI_SHIFT);
2323 vxlan_encap4(struct vxlan_softc *sc, const union vxlan_sockaddr *fvxlsa,
2329 struct in_addr srcaddr, dstaddr;
2330 uint16_t srcport, dstport;
2331 int len, mcast, error;
2334 srcaddr = sc->vxl_src_addr.in4.sin_addr;
2335 srcport = vxlan_pick_source_port(sc, m);
2336 dstaddr = fvxlsa->in4.sin_addr;
2337 dstport = fvxlsa->in4.sin_port;
2339 M_PREPEND(m, sizeof(struct ip) + sizeof(struct vxlanudphdr),
2342 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2346 len = m->m_pkthdr.len;
2348 ip = mtod(m, struct ip *);
2350 ip->ip_len = htons(len);
2352 ip->ip_ttl = sc->vxl_ttl;
2353 ip->ip_p = IPPROTO_UDP;
2355 ip->ip_src = srcaddr;
2356 ip->ip_dst = dstaddr;
2358 vxlan_encap_header(sc, m, sizeof(struct ip), srcport, dstport);
2360 mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0;
2361 m->m_flags &= ~(M_MCAST | M_BCAST);
2363 error = ip_output(m, NULL, NULL, 0, sc->vxl_im4o, NULL);
2365 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2366 if_inc_counter(ifp, IFCOUNTER_OBYTES, len);
2368 if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
2370 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2380 vxlan_encap6(struct vxlan_softc *sc, const union vxlan_sockaddr *fvxlsa,
2385 struct ip6_hdr *ip6;
2386 const struct in6_addr *srcaddr, *dstaddr;
2387 uint16_t srcport, dstport;
2388 int len, mcast, error;
2391 srcaddr = &sc->vxl_src_addr.in6.sin6_addr;
2392 srcport = vxlan_pick_source_port(sc, m);
2393 dstaddr = &fvxlsa->in6.sin6_addr;
2394 dstport = fvxlsa->in6.sin6_port;
2396 M_PREPEND(m, sizeof(struct ip6_hdr) + sizeof(struct vxlanudphdr),
2399 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2403 len = m->m_pkthdr.len;
2405 ip6 = mtod(m, struct ip6_hdr *);
2406 ip6->ip6_flow = 0; /* BMV: Keep in forwarding entry? */
2407 ip6->ip6_vfc = IPV6_VERSION;
2409 ip6->ip6_nxt = IPPROTO_UDP;
2410 ip6->ip6_hlim = sc->vxl_ttl;
2411 ip6->ip6_src = *srcaddr;
2412 ip6->ip6_dst = *dstaddr;
2414 vxlan_encap_header(sc, m, sizeof(struct ip6_hdr), srcport, dstport);
2417 * XXX BMV We need support for RFC6935 before we can send and
2418 * receive IPv6 UDP packets with a zero checksum.
2421 struct udphdr *hdr = mtodo(m, sizeof(struct ip6_hdr));
2422 hdr->uh_sum = in6_cksum_pseudo(ip6,
2423 m->m_pkthdr.len - sizeof(struct ip6_hdr), IPPROTO_UDP, 0);
2424 m->m_pkthdr.csum_flags = CSUM_UDP_IPV6;
2425 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
2428 mcast = (m->m_flags & (M_MCAST | M_BCAST)) ? 1 : 0;
2429 m->m_flags &= ~(M_MCAST | M_BCAST);
2431 error = ip6_output(m, NULL, NULL, 0, sc->vxl_im6o, NULL, NULL);
2433 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2434 if_inc_counter(ifp, IFCOUNTER_OBYTES, len);
2436 if_inc_counter(ifp, IFCOUNTER_OMCASTS, 1);
2438 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2448 vxlan_transmit(struct ifnet *ifp, struct mbuf *m)
2450 struct rm_priotracker tracker;
2451 union vxlan_sockaddr vxlsa;
2452 struct vxlan_softc *sc;
2453 struct vxlan_ftable_entry *fe;
2454 struct ifnet *mcifp;
2455 struct ether_header *eh;
2459 eh = mtod(m, struct ether_header *);
2463 ETHER_BPF_MTAP(ifp, m);
2465 VXLAN_RLOCK(sc, &tracker);
2466 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
2467 VXLAN_RUNLOCK(sc, &tracker);
2472 if ((m->m_flags & (M_BCAST | M_MCAST)) == 0)
2473 fe = vxlan_ftable_entry_lookup(sc, eh->ether_dhost);
2475 fe = &sc->vxl_default_fe;
2476 vxlan_sockaddr_copy(&vxlsa, &fe->vxlfe_raddr.sa);
2478 ipv4 = VXLAN_SOCKADDR_IS_IPV4(&vxlsa) != 0;
2479 if (vxlan_sockaddr_in_multicast(&vxlsa) != 0)
2480 mcifp = vxlan_multicast_if_ref(sc, ipv4);
2483 VXLAN_RUNLOCK(sc, &tracker);
2486 error = vxlan_encap4(sc, &vxlsa, m);
2488 error = vxlan_encap6(sc, &vxlsa, m);
2498 vxlan_qflush(struct ifnet *ifp __unused)
2503 vxlan_rcv_udp_packet(struct mbuf *m, int offset, struct inpcb *inpcb,
2504 const struct sockaddr *srcsa, void *xvso)
2506 struct vxlan_socket *vso;
2507 struct vxlan_header *vxh, vxlanhdr;
2513 offset += sizeof(struct udphdr);
2515 if (m->m_pkthdr.len < offset + sizeof(struct vxlan_header))
2518 if (__predict_false(m->m_len < offset + sizeof(struct vxlan_header))) {
2519 m_copydata(m, offset, sizeof(struct vxlan_header),
2520 (caddr_t) &vxlanhdr);
2523 vxh = mtodo(m, offset);
2526 * Drop if there is a reserved bit set in either the flags or VNI
2527 * fields of the header. This goes against the specification, but
2528 * a bit set may indicate an unsupported new feature. This matches
2529 * the behavior of the Linux implementation.
2531 if (vxh->vxlh_flags != htonl(VXLAN_HDR_FLAGS_VALID_VNI) ||
2532 vxh->vxlh_vni & ~htonl(VXLAN_VNI_MASK))
2535 vni = ntohl(vxh->vxlh_vni) >> VXLAN_HDR_VNI_SHIFT;
2536 /* Adjust to the start of the inner Ethernet frame. */
2537 m_adj(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);
2759 ether_ifattach(ifp, sc->vxl_hwaddr);
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_fakeaddr(struct vxlan_softc *sc)
2835 * Generate a non-multicast, locally administered address.
2837 * BMV: Should we use the FreeBSD OUI range instead?
2839 arc4rand(sc->vxl_hwaddr, ETHER_ADDR_LEN, 1);
2840 sc->vxl_hwaddr[0] &= ~1;
2841 sc->vxl_hwaddr[0] |= 2;
2845 vxlan_media_change(struct ifnet *ifp)
2853 vxlan_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
2856 ifmr->ifm_status = IFM_ACTIVE | IFM_AVALID;
2857 ifmr->ifm_active = IFM_ETHER | IFM_FDX;
2861 vxlan_sockaddr_cmp(const union vxlan_sockaddr *vxladdr,
2862 const struct sockaddr *sa)
2865 return (bcmp(&vxladdr->sa, sa, vxladdr->sa.sa_len));
2869 vxlan_sockaddr_copy(union vxlan_sockaddr *vxladdr,
2870 const struct sockaddr *sa)
2873 MPASS(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
2874 bzero(vxladdr, sizeof(*vxladdr));
2876 if (sa->sa_family == AF_INET) {
2877 vxladdr->in4 = *satoconstsin(sa);
2878 vxladdr->in4.sin_len = sizeof(struct sockaddr_in);
2879 } else if (sa->sa_family == AF_INET6) {
2880 vxladdr->in6 = *satoconstsin6(sa);
2881 vxladdr->in6.sin6_len = sizeof(struct sockaddr_in6);
2886 vxlan_sockaddr_in_equal(const union vxlan_sockaddr *vxladdr,
2887 const struct sockaddr *sa)
2891 if (sa->sa_family == AF_INET) {
2892 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2893 equal = in4->s_addr == vxladdr->in4.sin_addr.s_addr;
2894 } else if (sa->sa_family == AF_INET6) {
2895 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2896 equal = IN6_ARE_ADDR_EQUAL(in6, &vxladdr->in6.sin6_addr);
2904 vxlan_sockaddr_in_copy(union vxlan_sockaddr *vxladdr,
2905 const struct sockaddr *sa)
2908 MPASS(sa->sa_family == AF_INET || sa->sa_family == AF_INET6);
2910 if (sa->sa_family == AF_INET) {
2911 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2912 vxladdr->in4.sin_family = AF_INET;
2913 vxladdr->in4.sin_len = sizeof(struct sockaddr_in);
2914 vxladdr->in4.sin_addr = *in4;
2915 } else if (sa->sa_family == AF_INET6) {
2916 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2917 vxladdr->in6.sin6_family = AF_INET6;
2918 vxladdr->in6.sin6_len = sizeof(struct sockaddr_in6);
2919 vxladdr->in6.sin6_addr = *in6;
2924 vxlan_sockaddr_supported(const union vxlan_sockaddr *vxladdr, int unspec)
2926 const struct sockaddr *sa;
2932 if (sa->sa_family == AF_UNSPEC && unspec != 0) {
2934 } else if (sa->sa_family == AF_INET) {
2938 } else if (sa->sa_family == AF_INET6) {
2948 vxlan_sockaddr_in_any(const union vxlan_sockaddr *vxladdr)
2950 const struct sockaddr *sa;
2955 if (sa->sa_family == AF_INET) {
2956 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2957 any = in4->s_addr == INADDR_ANY;
2958 } else if (sa->sa_family == AF_INET6) {
2959 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2960 any = IN6_IS_ADDR_UNSPECIFIED(in6);
2968 vxlan_sockaddr_in_multicast(const union vxlan_sockaddr *vxladdr)
2970 const struct sockaddr *sa;
2975 if (sa->sa_family == AF_INET) {
2976 const struct in_addr *in4 = &satoconstsin(sa)->sin_addr;
2977 mc = IN_MULTICAST(ntohl(in4->s_addr));
2978 } else if (sa->sa_family == AF_INET6) {
2979 const struct in6_addr *in6 = &satoconstsin6(sa)->sin6_addr;
2980 mc = IN6_IS_ADDR_MULTICAST(in6);
2988 vxlan_sockaddr_in6_embedscope(union vxlan_sockaddr *vxladdr)
2992 MPASS(VXLAN_SOCKADDR_IS_IPV6(vxladdr));
2994 error = sa6_embedscope(&vxladdr->in6, V_ip6_use_defzone);
2996 error = EAFNOSUPPORT;
3003 vxlan_can_change_config(struct vxlan_softc *sc)
3008 VXLAN_LOCK_ASSERT(sc);
3010 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
3012 if (sc->vxl_flags & (VXLAN_FLAG_INIT | VXLAN_FLAG_TEARDOWN))
3019 vxlan_check_vni(uint32_t vni)
3022 return (vni >= VXLAN_VNI_MAX);
3026 vxlan_check_ttl(int ttl)
3029 return (ttl > MAXTTL);
3033 vxlan_check_ftable_timeout(uint32_t timeout)
3036 return (timeout > VXLAN_FTABLE_MAX_TIMEOUT);
3040 vxlan_check_ftable_max(uint32_t max)
3043 return (max > VXLAN_FTABLE_MAX);
3047 vxlan_sysctl_setup(struct vxlan_softc *sc)
3049 struct sysctl_ctx_list *ctx;
3050 struct sysctl_oid *node;
3051 struct vxlan_statistics *stats;
3054 ctx = &sc->vxl_sysctl_ctx;
3055 stats = &sc->vxl_stats;
3056 snprintf(namebuf, sizeof(namebuf), "%d", sc->vxl_unit);
3058 sysctl_ctx_init(ctx);
3059 sc->vxl_sysctl_node = SYSCTL_ADD_NODE(ctx,
3060 SYSCTL_STATIC_CHILDREN(_net_link_vxlan), OID_AUTO, namebuf,
3061 CTLFLAG_RD, NULL, "");
3063 node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sc->vxl_sysctl_node),
3064 OID_AUTO, "ftable", CTLFLAG_RD, NULL, "");
3065 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "count",
3066 CTLFLAG_RD, &sc->vxl_ftable_cnt, 0,
3067 "Number of entries in fowarding table");
3068 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "max",
3069 CTLFLAG_RD, &sc->vxl_ftable_max, 0,
3070 "Maximum number of entries allowed in fowarding table");
3071 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "timeout",
3072 CTLFLAG_RD, &sc->vxl_ftable_timeout, 0,
3073 "Number of seconds between prunes of the forwarding table");
3074 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(node), OID_AUTO, "dump",
3075 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE | CTLFLAG_SKIP,
3076 sc, 0, vxlan_ftable_sysctl_dump, "A",
3077 "Dump the forwarding table entries");
3079 node = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(sc->vxl_sysctl_node),
3080 OID_AUTO, "stats", CTLFLAG_RD, NULL, "");
3081 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
3082 "ftable_nospace", CTLFLAG_RD, &stats->ftable_nospace, 0,
3083 "Fowarding table reached maximum entries");
3084 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
3085 "ftable_lock_upgrade_failed", CTLFLAG_RD,
3086 &stats->ftable_lock_upgrade_failed, 0,
3087 "Forwarding table update required lock upgrade");
3091 vxlan_sysctl_destroy(struct vxlan_softc *sc)
3094 sysctl_ctx_free(&sc->vxl_sysctl_ctx);
3095 sc->vxl_sysctl_node = NULL;
3099 vxlan_tunable_int(struct vxlan_softc *sc, const char *knob, int def)
3103 snprintf(path, sizeof(path), "net.link.vxlan.%d.%s",
3104 sc->vxl_unit, knob);
3105 TUNABLE_INT_FETCH(path, &def);
3111 vxlan_ifdetach_event(void *arg __unused, struct ifnet *ifp)
3113 struct vxlan_softc_head list;
3114 struct vxlan_socket *vso;
3115 struct vxlan_softc *sc, *tsc;
3119 if (ifp->if_flags & IFF_RENAMING)
3121 if ((ifp->if_flags & IFF_MULTICAST) == 0)
3125 LIST_FOREACH(vso, &vxlan_socket_list, vxlso_entry)
3126 vxlan_socket_ifdetach(vso, ifp, &list);
3127 VXLAN_LIST_UNLOCK();
3129 LIST_FOREACH_SAFE(sc, &list, vxl_ifdetach_list, tsc) {
3130 LIST_REMOVE(sc, vxl_ifdetach_list);
3133 if (sc->vxl_flags & VXLAN_FLAG_INIT)
3134 vxlan_init_wait(sc);
3135 vxlan_teardown_locked(sc);
3143 mtx_init(&vxlan_list_mtx, "vxlan list", NULL, MTX_DEF);
3144 LIST_INIT(&vxlan_socket_list);
3145 vxlan_ifdetach_event_tag = EVENTHANDLER_REGISTER(ifnet_departure_event,
3146 vxlan_ifdetach_event, NULL, EVENTHANDLER_PRI_ANY);
3147 vxlan_cloner = if_clone_simple(vxlan_name, vxlan_clone_create,
3148 vxlan_clone_destroy, 0);
3155 EVENTHANDLER_DEREGISTER(ifnet_departure_event,
3156 vxlan_ifdetach_event_tag);
3157 if_clone_detach(vxlan_cloner);
3158 mtx_destroy(&vxlan_list_mtx);
3159 MPASS(LIST_EMPTY(&vxlan_socket_list));
3163 vxlan_modevent(module_t mod, int type, void *unused)
3184 static moduledata_t vxlan_mod = {
3190 DECLARE_MODULE(if_vxlan, vxlan_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
3191 MODULE_VERSION(if_vxlan, 1);