sys/net/if_vxlan.c

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