drivers/net/vxlan.c

   1 /*
   2  * VXLAN: Virtual eXtensible Local Area Network
   3  *
   4  * Copyright (c) 2012-2013 Vyatta Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/kernel.h>
  14 #include <linux/types.h>
  15 #include <linux/module.h>
  16 #include <linux/errno.h>
  17 #include <linux/slab.h>
  18 #include <linux/skbuff.h>
  19 #include <linux/rculist.h>
  20 #include <linux/netdevice.h>
  21 #include <linux/in.h>
  22 #include <linux/ip.h>
  23 #include <linux/udp.h>
  24 #include <linux/igmp.h>
  25 #include <linux/etherdevice.h>
  26 #include <linux/if_ether.h>
  27 #include <linux/if_vlan.h>
  28 #include <linux/hash.h>
  29 #include <linux/ethtool.h>
  30 #include <net/arp.h>
  31 #include <net/ndisc.h>
  32 #include <net/ip.h>
  33 #include <net/ip_tunnels.h>
  34 #include <net/icmp.h>
  35 #include <net/udp.h>
  36 #include <net/rtnetlink.h>
  37 #include <net/route.h>
  38 #include <net/dsfield.h>
  39 #include <net/inet_ecn.h>
  40 #include <net/net_namespace.h>
  41 #include <net/netns/generic.h>
  42 #include <net/vxlan.h>
  43 #if IS_ENABLED(CONFIG_IPV6)
  44 #include <net/ipv6.h>
  45 #include <net/addrconf.h>
  46 #include <net/ip6_tunnel.h>
  47 #include <net/ip6_checksum.h>
  48 #endif
  49
  50 #define VXLAN_VERSION   "0.1"
  51
  52 #define PORT_HASH_BITS  8
  53 #define PORT_HASH_SIZE  (1<<PORT_HASH_BITS)
  54 #define VNI_HASH_BITS   10
  55 #define VNI_HASH_SIZE   (1<<VNI_HASH_BITS)
  56 #define FDB_HASH_BITS   8
  57 #define FDB_HASH_SIZE   (1<<FDB_HASH_BITS)
  58 #define FDB_AGE_DEFAULT 300 /* 5 min */
  59 #define FDB_AGE_INTERVAL (10 * HZ)      /* rescan interval */
  60
  61 #define VXLAN_N_VID     (1u << 24)
  62 #define VXLAN_VID_MASK  (VXLAN_N_VID - 1)
  63 #define VXLAN_HLEN (sizeof(struct udphdr) + sizeof(struct vxlanhdr))
  64
  65 #define VXLAN_FLAGS 0x08000000  /* struct vxlanhdr.vx_flags required value. */
  66
  67 /* VXLAN protocol header */
  68 struct vxlanhdr {
  69         __be32 vx_flags;
  70         __be32 vx_vni;
  71 };
  72
  73 /* UDP port for VXLAN traffic.
  74  * The IANA assigned port is 4789, but the Linux default is 8472
  75  * for compatibility with early adopters.
  76  */
  77 static unsigned short vxlan_port __read_mostly = 8472;
  78 module_param_named(udp_port, vxlan_port, ushort, 0444);
  79 MODULE_PARM_DESC(udp_port, "Destination UDP port");
  80
  81 static bool log_ecn_error = true;
  82 module_param(log_ecn_error, bool, 0644);
  83 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
  84
  85 static int vxlan_net_id;
  86
  87 static const u8 all_zeros_mac[ETH_ALEN];
  88
  89 /* per-network namespace private data for this module */
  90 struct vxlan_net {
  91         struct list_head  vxlan_list;
  92         struct hlist_head sock_list[PORT_HASH_SIZE];
  93         spinlock_t        sock_lock;
  94 };
  95
  96 union vxlan_addr {
  97         struct sockaddr_in sin;
  98         struct sockaddr_in6 sin6;
  99         struct sockaddr sa;
 100 };
 101
 102 struct vxlan_rdst {
 103         union vxlan_addr         remote_ip;
 104         __be16                   remote_port;
 105         u32                      remote_vni;
 106         u32                      remote_ifindex;
 107         struct list_head         list;
 108         struct rcu_head          rcu;
 109 };
 110
 111 /* Forwarding table entry */
 112 struct vxlan_fdb {
 113         struct hlist_node hlist;        /* linked list of entries */
 114         struct rcu_head   rcu;
 115         unsigned long     updated;      /* jiffies */
 116         unsigned long     used;
 117         struct list_head  remotes;
 118         u16               state;        /* see ndm_state */
 119         u8                flags;        /* see ndm_flags */
 120         u8                eth_addr[ETH_ALEN];
 121 };
 122
 123 /* Pseudo network device */
 124 struct vxlan_dev {
 125         struct hlist_node hlist;        /* vni hash table */
 126         struct list_head  next;         /* vxlan's per namespace list */
 127         struct vxlan_sock *vn_sock;     /* listening socket */
 128         struct net_device *dev;
 129         struct vxlan_rdst default_dst;  /* default destination */
 130         union vxlan_addr  saddr;        /* source address */
 131         __be16            dst_port;
 132         __u16             port_min;     /* source port range */
 133         __u16             port_max;
 134         __u8              tos;          /* TOS override */
 135         __u8              ttl;
 136         u32               flags;        /* VXLAN_F_* below */
 137
 138         struct work_struct sock_work;
 139         struct work_struct igmp_join;
 140         struct work_struct igmp_leave;
 141
 142         unsigned long     age_interval;
 143         struct timer_list age_timer;
 144         spinlock_t        hash_lock;
 145         unsigned int      addrcnt;
 146         unsigned int      addrmax;
 147
 148         struct hlist_head fdb_head[FDB_HASH_SIZE];
 149 };
 150
 151 #define VXLAN_F_LEARN   0x01
 152 #define VXLAN_F_PROXY   0x02
 153 #define VXLAN_F_RSC     0x04
 154 #define VXLAN_F_L2MISS  0x08
 155 #define VXLAN_F_L3MISS  0x10
 156 #define VXLAN_F_IPV6    0x20 /* internal flag */
 157
 158 /* salt for hash table */
 159 static u32 vxlan_salt __read_mostly;
 160 static struct workqueue_struct *vxlan_wq;
 161
 162 static void vxlan_sock_work(struct work_struct *work);
 163
 164 #if IS_ENABLED(CONFIG_IPV6)
 165 static inline
 166 bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
 167 {
 168        if (a->sa.sa_family != b->sa.sa_family)
 169                return false;
 170        if (a->sa.sa_family == AF_INET6)
 171                return ipv6_addr_equal(&a->sin6.sin6_addr, &b->sin6.sin6_addr);
 172        else
 173                return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
 174 }
 175
 176 static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
 177 {
 178        if (ipa->sa.sa_family == AF_INET6)
 179                return ipv6_addr_any(&ipa->sin6.sin6_addr);
 180        else
 181                return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
 182 }
 183
 184 static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
 185 {
 186        if (ipa->sa.sa_family == AF_INET6)
 187                return ipv6_addr_is_multicast(&ipa->sin6.sin6_addr);
 188        else
 189                return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
 190 }
 191
 192 static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
 193 {
 194        if (nla_len(nla) >= sizeof(struct in6_addr)) {
 195                nla_memcpy(&ip->sin6.sin6_addr, nla, sizeof(struct in6_addr));
 196                ip->sa.sa_family = AF_INET6;
 197                return 0;
 198        } else if (nla_len(nla) >= sizeof(__be32)) {
 199                ip->sin.sin_addr.s_addr = nla_get_be32(nla);
 200                ip->sa.sa_family = AF_INET;
 201                return 0;
 202        } else {
 203                return -EAFNOSUPPORT;
 204        }
 205 }
 206
 207 static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
 208                              const union vxlan_addr *ip)
 209 {
 210        if (ip->sa.sa_family == AF_INET6)
 211                return nla_put(skb, attr, sizeof(struct in6_addr), &ip->sin6.sin6_addr);
 212        else
 213                return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);
 214 }
 215
 216 #else /* !CONFIG_IPV6 */
 217
 218 static inline
 219 bool vxlan_addr_equal(const union vxlan_addr *a, const union vxlan_addr *b)
 220 {
 221        return a->sin.sin_addr.s_addr == b->sin.sin_addr.s_addr;
 222 }
 223
 224 static inline bool vxlan_addr_any(const union vxlan_addr *ipa)
 225 {
 226        return ipa->sin.sin_addr.s_addr == htonl(INADDR_ANY);
 227 }
 228
 229 static inline bool vxlan_addr_multicast(const union vxlan_addr *ipa)
 230 {
 231        return IN_MULTICAST(ntohl(ipa->sin.sin_addr.s_addr));
 232 }
 233
 234 static int vxlan_nla_get_addr(union vxlan_addr *ip, struct nlattr *nla)
 235 {
 236        if (nla_len(nla) >= sizeof(struct in6_addr)) {
 237                return -EAFNOSUPPORT;
 238        } else if (nla_len(nla) >= sizeof(__be32)) {
 239                ip->sin.sin_addr.s_addr = nla_get_be32(nla);
 240                ip->sa.sa_family = AF_INET;
 241                return 0;
 242        } else {
 243                return -EAFNOSUPPORT;
 244        }
 245 }
 246
 247 static int vxlan_nla_put_addr(struct sk_buff *skb, int attr,
 248                              const union vxlan_addr *ip)
 249 {
 250        return nla_put_be32(skb, attr, ip->sin.sin_addr.s_addr);
 251 }
 252 #endif
 253
 254 /* Virtual Network hash table head */
 255 static inline struct hlist_head *vni_head(struct vxlan_sock *vs, u32 id)
 256 {
 257         return &vs->vni_list[hash_32(id, VNI_HASH_BITS)];
 258 }
 259
 260 /* Socket hash table head */
 261 static inline struct hlist_head *vs_head(struct net *net, __be16 port)
 262 {
 263         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 264
 265         return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
 266 }
 267
 268 /* First remote destination for a forwarding entry.
 269  * Guaranteed to be non-NULL because remotes are never deleted.
 270  */
 271 static inline struct vxlan_rdst *first_remote_rcu(struct vxlan_fdb *fdb)
 272 {
 273         return list_entry_rcu(fdb->remotes.next, struct vxlan_rdst, list);
 274 }
 275
 276 static inline struct vxlan_rdst *first_remote_rtnl(struct vxlan_fdb *fdb)
 277 {
 278         return list_first_entry(&fdb->remotes, struct vxlan_rdst, list);
 279 }
 280
 281 /* Find VXLAN socket based on network namespace and UDP port */
 282 static struct vxlan_sock *vxlan_find_sock(struct net *net, __be16 port)
 283 {
 284         struct vxlan_sock *vs;
 285
 286         hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {
 287                 if (inet_sk(vs->sock->sk)->inet_sport == port)
 288                         return vs;
 289         }
 290         return NULL;
 291 }
 292
 293 static struct vxlan_dev *vxlan_vs_find_vni(struct vxlan_sock *vs, u32 id)
 294 {
 295         struct vxlan_dev *vxlan;
 296
 297         hlist_for_each_entry_rcu(vxlan, vni_head(vs, id), hlist) {
 298                 if (vxlan->default_dst.remote_vni == id)
 299                         return vxlan;
 300         }
 301
 302         return NULL;
 303 }
 304
 305 /* Look up VNI in a per net namespace table */
 306 static struct vxlan_dev *vxlan_find_vni(struct net *net, u32 id, __be16 port)
 307 {
 308         struct vxlan_sock *vs;
 309
 310         vs = vxlan_find_sock(net, port);
 311         if (!vs)
 312                 return NULL;
 313
 314         return vxlan_vs_find_vni(vs, id);
 315 }
 316
 317 /* Fill in neighbour message in skbuff. */
 318 static int vxlan_fdb_info(struct sk_buff *skb, struct vxlan_dev *vxlan,
 319                           const struct vxlan_fdb *fdb,
 320                           u32 portid, u32 seq, int type, unsigned int flags,
 321                           const struct vxlan_rdst *rdst)
 322 {
 323         unsigned long now = jiffies;
 324         struct nda_cacheinfo ci;
 325         struct nlmsghdr *nlh;
 326         struct ndmsg *ndm;
 327         bool send_ip, send_eth;
 328
 329         nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
 330         if (nlh == NULL)
 331                 return -EMSGSIZE;
 332
 333         ndm = nlmsg_data(nlh);
 334         memset(ndm, 0, sizeof(*ndm));
 335
 336         send_eth = send_ip = true;
 337
 338         if (type == RTM_GETNEIGH) {
 339                 ndm->ndm_family = AF_INET;
 340                 send_ip = !vxlan_addr_any(&rdst->remote_ip);
 341                 send_eth = !is_zero_ether_addr(fdb->eth_addr);
 342         } else
 343                 ndm->ndm_family = AF_BRIDGE;
 344         ndm->ndm_state = fdb->state;
 345         ndm->ndm_ifindex = vxlan->dev->ifindex;
 346         ndm->ndm_flags = fdb->flags;
 347         ndm->ndm_type = NDA_DST;
 348
 349         if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))
 350                 goto nla_put_failure;
 351
 352         if (send_ip && vxlan_nla_put_addr(skb, NDA_DST, &rdst->remote_ip))
 353                 goto nla_put_failure;
 354
 355         if (rdst->remote_port && rdst->remote_port != vxlan->dst_port &&
 356             nla_put_be16(skb, NDA_PORT, rdst->remote_port))
 357                 goto nla_put_failure;
 358         if (rdst->remote_vni != vxlan->default_dst.remote_vni &&
 359             nla_put_u32(skb, NDA_VNI, rdst->remote_vni))
 360                 goto nla_put_failure;
 361         if (rdst->remote_ifindex &&
 362             nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
 363                 goto nla_put_failure;
 364
 365         ci.ndm_used      = jiffies_to_clock_t(now - fdb->used);
 366         ci.ndm_confirmed = 0;
 367         ci.ndm_updated   = jiffies_to_clock_t(now - fdb->updated);
 368         ci.ndm_refcnt    = 0;
 369
 370         if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
 371                 goto nla_put_failure;
 372
 373         return nlmsg_end(skb, nlh);
 374
 375 nla_put_failure:
 376         nlmsg_cancel(skb, nlh);
 377         return -EMSGSIZE;
 378 }
 379
 380 static inline size_t vxlan_nlmsg_size(void)
 381 {
 382         return NLMSG_ALIGN(sizeof(struct ndmsg))
 383                 + nla_total_size(ETH_ALEN) /* NDA_LLADDR */
 384                 + nla_total_size(sizeof(struct in6_addr)) /* NDA_DST */
 385                 + nla_total_size(sizeof(__be16)) /* NDA_PORT */
 386                 + nla_total_size(sizeof(__be32)) /* NDA_VNI */
 387                 + nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
 388                 + nla_total_size(sizeof(struct nda_cacheinfo));
 389 }
 390
 391 static void vxlan_fdb_notify(struct vxlan_dev *vxlan,
 392                              struct vxlan_fdb *fdb, int type)
 393 {
 394         struct net *net = dev_net(vxlan->dev);
 395         struct sk_buff *skb;
 396         int err = -ENOBUFS;
 397
 398         skb = nlmsg_new(vxlan_nlmsg_size(), GFP_ATOMIC);
 399         if (skb == NULL)
 400                 goto errout;
 401
 402         err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0,
 403                              first_remote_rtnl(fdb));
 404         if (err < 0) {
 405                 /* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */
 406                 WARN_ON(err == -EMSGSIZE);
 407                 kfree_skb(skb);
 408                 goto errout;
 409         }
 410
 411         rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
 412         return;
 413 errout:
 414         if (err < 0)
 415                 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
 416 }
 417
 418 static void vxlan_ip_miss(struct net_device *dev, union vxlan_addr *ipa)
 419 {
 420         struct vxlan_dev *vxlan = netdev_priv(dev);
 421         struct vxlan_fdb f = {
 422                 .state = NUD_STALE,
 423         };
 424         struct vxlan_rdst remote = {
 425                 .remote_ip = *ipa, /* goes to NDA_DST */
 426                 .remote_vni = VXLAN_N_VID,
 427         };
 428
 429         INIT_LIST_HEAD(&f.remotes);
 430         list_add_rcu(&remote.list, &f.remotes);
 431
 432         vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
 433 }
 434
 435 static void vxlan_fdb_miss(struct vxlan_dev *vxlan, const u8 eth_addr[ETH_ALEN])
 436 {
 437         struct vxlan_fdb f = {
 438                 .state = NUD_STALE,
 439         };
 440
 441         INIT_LIST_HEAD(&f.remotes);
 442         memcpy(f.eth_addr, eth_addr, ETH_ALEN);
 443
 444         vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
 445 }
 446
 447 /* Hash Ethernet address */
 448 static u32 eth_hash(const unsigned char *addr)
 449 {
 450         u64 value = get_unaligned((u64 *)addr);
 451
 452         /* only want 6 bytes */
 453 #ifdef __BIG_ENDIAN
 454         value >>= 16;
 455 #else
 456         value <<= 16;
 457 #endif
 458         return hash_64(value, FDB_HASH_BITS);
 459 }
 460
 461 /* Hash chain to use given mac address */
 462 static inline struct hlist_head *vxlan_fdb_head(struct vxlan_dev *vxlan,
 463                                                 const u8 *mac)
 464 {
 465         return &vxlan->fdb_head[eth_hash(mac)];
 466 }
 467
 468 /* Look up Ethernet address in forwarding table */
 469 static struct vxlan_fdb *__vxlan_find_mac(struct vxlan_dev *vxlan,
 470                                         const u8 *mac)
 471
 472 {
 473         struct hlist_head *head = vxlan_fdb_head(vxlan, mac);
 474         struct vxlan_fdb *f;
 475
 476         hlist_for_each_entry_rcu(f, head, hlist) {
 477                 if (ether_addr_equal(mac, f->eth_addr))
 478                         return f;
 479         }
 480
 481         return NULL;
 482 }
 483
 484 static struct vxlan_fdb *vxlan_find_mac(struct vxlan_dev *vxlan,
 485                                         const u8 *mac)
 486 {
 487         struct vxlan_fdb *f;
 488
 489         f = __vxlan_find_mac(vxlan, mac);
 490         if (f)
 491                 f->used = jiffies;
 492
 493         return f;
 494 }
 495
 496 /* caller should hold vxlan->hash_lock */
 497 static struct vxlan_rdst *vxlan_fdb_find_rdst(struct vxlan_fdb *f,
 498                                               union vxlan_addr *ip, __be16 port,
 499                                               __u32 vni, __u32 ifindex)
 500 {
 501         struct vxlan_rdst *rd;
 502
 503         list_for_each_entry(rd, &f->remotes, list) {
 504                 if (vxlan_addr_equal(&rd->remote_ip, ip) &&
 505                     rd->remote_port == port &&
 506                     rd->remote_vni == vni &&
 507                     rd->remote_ifindex == ifindex)
 508                         return rd;
 509         }
 510
 511         return NULL;
 512 }
 513
 514 /* Replace destination of unicast mac */
 515 static int vxlan_fdb_replace(struct vxlan_fdb *f,
 516                              union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)
 517 {
 518         struct vxlan_rdst *rd;
 519
 520         rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
 521         if (rd)
 522                 return 0;
 523
 524         rd = list_first_entry_or_null(&f->remotes, struct vxlan_rdst, list);
 525         if (!rd)
 526                 return 0;
 527         rd->remote_ip = *ip;
 528         rd->remote_port = port;
 529         rd->remote_vni = vni;
 530         rd->remote_ifindex = ifindex;
 531         return 1;
 532 }
 533
 534 /* Add/update destinations for multicast */
 535 static int vxlan_fdb_append(struct vxlan_fdb *f,
 536                             union vxlan_addr *ip, __be16 port, __u32 vni, __u32 ifindex)
 537 {
 538         struct vxlan_rdst *rd;
 539
 540         rd = vxlan_fdb_find_rdst(f, ip, port, vni, ifindex);
 541         if (rd)
 542                 return 0;
 543
 544         rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
 545         if (rd == NULL)
 546                 return -ENOBUFS;
 547         rd->remote_ip = *ip;
 548         rd->remote_port = port;
 549         rd->remote_vni = vni;
 550         rd->remote_ifindex = ifindex;
 551
 552         list_add_tail_rcu(&rd->list, &f->remotes);
 553
 554         return 1;
 555 }
 556
 557 /* Notify netdevs that UDP port started listening */
 558 static void vxlan_notify_add_rx_port(struct sock *sk)
 559 {
 560         struct net_device *dev;
 561         struct net *net = sock_net(sk);
 562         sa_family_t sa_family = sk->sk_family;
 563         __be16 port = inet_sk(sk)->inet_sport;
 564
 565         rcu_read_lock();
 566         for_each_netdev_rcu(net, dev) {
 567                 if (dev->netdev_ops->ndo_add_vxlan_port)
 568                         dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,
 569                                                             port);
 570         }
 571         rcu_read_unlock();
 572 }
 573
 574 /* Notify netdevs that UDP port is no more listening */
 575 static void vxlan_notify_del_rx_port(struct sock *sk)
 576 {
 577         struct net_device *dev;
 578         struct net *net = sock_net(sk);
 579         sa_family_t sa_family = sk->sk_family;
 580         __be16 port = inet_sk(sk)->inet_sport;
 581
 582         rcu_read_lock();
 583         for_each_netdev_rcu(net, dev) {
 584                 if (dev->netdev_ops->ndo_del_vxlan_port)
 585                         dev->netdev_ops->ndo_del_vxlan_port(dev, sa_family,
 586                                                             port);
 587         }
 588         rcu_read_unlock();
 589 }
 590
 591 /* Add new entry to forwarding table -- assumes lock held */
 592 static int vxlan_fdb_create(struct vxlan_dev *vxlan,
 593                             const u8 *mac, union vxlan_addr *ip,
 594                             __u16 state, __u16 flags,
 595                             __be16 port, __u32 vni, __u32 ifindex,
 596                             __u8 ndm_flags)
 597 {
 598         struct vxlan_fdb *f;
 599         int notify = 0;
 600
 601         f = __vxlan_find_mac(vxlan, mac);
 602         if (f) {
 603                 if (flags & NLM_F_EXCL) {
 604                         netdev_dbg(vxlan->dev,
 605                                    "lost race to create %pM\n", mac);
 606                         return -EEXIST;
 607                 }
 608                 if (f->state != state) {
 609                         f->state = state;
 610                         f->updated = jiffies;
 611                         notify = 1;
 612                 }
 613                 if (f->flags != ndm_flags) {
 614                         f->flags = ndm_flags;
 615                         f->updated = jiffies;
 616                         notify = 1;
 617                 }
 618                 if ((flags & NLM_F_REPLACE)) {
 619                         /* Only change unicasts */
 620                         if (!(is_multicast_ether_addr(f->eth_addr) ||
 621                              is_zero_ether_addr(f->eth_addr))) {
 622                                 int rc = vxlan_fdb_replace(f, ip, port, vni,
 623                                                            ifindex);
 624
 625                                 if (rc < 0)
 626                                         return rc;
 627                                 notify |= rc;
 628                         } else
 629                                 return -EOPNOTSUPP;
 630                 }
 631                 if ((flags & NLM_F_APPEND) &&
 632                     (is_multicast_ether_addr(f->eth_addr) ||
 633                      is_zero_ether_addr(f->eth_addr))) {
 634                         int rc = vxlan_fdb_append(f, ip, port, vni, ifindex);
 635
 636                         if (rc < 0)
 637                                 return rc;
 638                         notify |= rc;
 639                 }
 640         } else {
 641                 if (!(flags & NLM_F_CREATE))
 642                         return -ENOENT;
 643
 644                 if (vxlan->addrmax && vxlan->addrcnt >= vxlan->addrmax)
 645                         return -ENOSPC;
 646
 647                 /* Disallow replace to add a multicast entry */
 648                 if ((flags & NLM_F_REPLACE) &&
 649                     (is_multicast_ether_addr(mac) || is_zero_ether_addr(mac)))
 650                         return -EOPNOTSUPP;
 651
 652                 netdev_dbg(vxlan->dev, "add %pM -> %pIS\n", mac, ip);
 653                 f = kmalloc(sizeof(*f), GFP_ATOMIC);
 654                 if (!f)
 655                         return -ENOMEM;
 656
 657                 notify = 1;
 658                 f->state = state;
 659                 f->flags = ndm_flags;
 660                 f->updated = f->used = jiffies;
 661                 INIT_LIST_HEAD(&f->remotes);
 662                 memcpy(f->eth_addr, mac, ETH_ALEN);
 663
 664                 vxlan_fdb_append(f, ip, port, vni, ifindex);
 665
 666                 ++vxlan->addrcnt;
 667                 hlist_add_head_rcu(&f->hlist,
 668                                    vxlan_fdb_head(vxlan, mac));
 669         }
 670
 671         if (notify)
 672                 vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);
 673
 674         return 0;
 675 }
 676
 677 static void vxlan_fdb_free(struct rcu_head *head)
 678 {
 679         struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);
 680         struct vxlan_rdst *rd, *nd;
 681
 682         list_for_each_entry_safe(rd, nd, &f->remotes, list)
 683                 kfree(rd);
 684         kfree(f);
 685 }
 686
 687 static void vxlan_fdb_destroy(struct vxlan_dev *vxlan, struct vxlan_fdb *f)
 688 {
 689         netdev_dbg(vxlan->dev,
 690                     "delete %pM\n", f->eth_addr);
 691
 692         --vxlan->addrcnt;
 693         vxlan_fdb_notify(vxlan, f, RTM_DELNEIGH);
 694
 695         hlist_del_rcu(&f->hlist);
 696         call_rcu(&f->rcu, vxlan_fdb_free);
 697 }
 698
 699 static int vxlan_fdb_parse(struct nlattr *tb[], struct vxlan_dev *vxlan,
 700                            union vxlan_addr *ip, __be16 *port, u32 *vni, u32 *ifindex)
 701 {
 702         struct net *net = dev_net(vxlan->dev);
 703         int err;
 704
 705         if (tb[NDA_DST]) {
 706                 err = vxlan_nla_get_addr(ip, tb[NDA_DST]);
 707                 if (err)
 708                         return err;
 709         } else {
 710                 union vxlan_addr *remote = &vxlan->default_dst.remote_ip;
 711                 if (remote->sa.sa_family == AF_INET) {
 712                         ip->sin.sin_addr.s_addr = htonl(INADDR_ANY);
 713                         ip->sa.sa_family = AF_INET;
 714 #if IS_ENABLED(CONFIG_IPV6)
 715                 } else {
 716                         ip->sin6.sin6_addr = in6addr_any;
 717                         ip->sa.sa_family = AF_INET6;
 718 #endif
 719                 }
 720         }
 721
 722         if (tb[NDA_PORT]) {
 723                 if (nla_len(tb[NDA_PORT]) != sizeof(__be16))
 724                         return -EINVAL;
 725                 *port = nla_get_be16(tb[NDA_PORT]);
 726         } else {
 727                 *port = vxlan->dst_port;
 728         }
 729
 730         if (tb[NDA_VNI]) {
 731                 if (nla_len(tb[NDA_VNI]) != sizeof(u32))
 732                         return -EINVAL;
 733                 *vni = nla_get_u32(tb[NDA_VNI]);
 734         } else {
 735                 *vni = vxlan->default_dst.remote_vni;
 736         }
 737
 738         if (tb[NDA_IFINDEX]) {
 739                 struct net_device *tdev;
 740
 741                 if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
 742                         return -EINVAL;
 743                 *ifindex = nla_get_u32(tb[NDA_IFINDEX]);
 744                 tdev = __dev_get_by_index(net, *ifindex);
 745                 if (!tdev)
 746                         return -EADDRNOTAVAIL;
 747         } else {
 748                 *ifindex = 0;
 749         }
 750
 751         return 0;
 752 }
 753
 754 /* Add static entry (via netlink) */
 755 static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
 756                          struct net_device *dev,
 757                          const unsigned char *addr, u16 flags)
 758 {
 759         struct vxlan_dev *vxlan = netdev_priv(dev);
 760         /* struct net *net = dev_net(vxlan->dev); */
 761         union vxlan_addr ip;
 762         __be16 port;
 763         u32 vni, ifindex;
 764         int err;
 765
 766         if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_REACHABLE))) {
 767                 pr_info("RTM_NEWNEIGH with invalid state %#x\n",
 768                         ndm->ndm_state);
 769                 return -EINVAL;
 770         }
 771
 772         if (tb[NDA_DST] == NULL)
 773                 return -EINVAL;
 774
 775         err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);
 776         if (err)
 777                 return err;
 778
 779         spin_lock_bh(&vxlan->hash_lock);
 780         err = vxlan_fdb_create(vxlan, addr, &ip, ndm->ndm_state, flags,
 781                                port, vni, ifindex, ndm->ndm_flags);
 782         spin_unlock_bh(&vxlan->hash_lock);
 783
 784         return err;
 785 }
 786
 787 /* Delete entry (via netlink) */
 788 static int vxlan_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
 789                             struct net_device *dev,
 790                             const unsigned char *addr)
 791 {
 792         struct vxlan_dev *vxlan = netdev_priv(dev);
 793         struct vxlan_fdb *f;
 794         struct vxlan_rdst *rd = NULL;
 795         union vxlan_addr ip;
 796         __be16 port;
 797         u32 vni, ifindex;
 798         int err;
 799
 800         err = vxlan_fdb_parse(tb, vxlan, &ip, &port, &vni, &ifindex);
 801         if (err)
 802                 return err;
 803
 804         err = -ENOENT;
 805
 806         spin_lock_bh(&vxlan->hash_lock);
 807         f = vxlan_find_mac(vxlan, addr);
 808         if (!f)
 809                 goto out;
 810
 811         if (!vxlan_addr_any(&ip)) {
 812                 rd = vxlan_fdb_find_rdst(f, &ip, port, vni, ifindex);
 813                 if (!rd)
 814                         goto out;
 815         }
 816
 817         err = 0;
 818
 819         /* remove a destination if it's not the only one on the list,
 820          * otherwise destroy the fdb entry
 821          */
 822         if (rd && !list_is_singular(&f->remotes)) {
 823                 list_del_rcu(&rd->list);
 824                 kfree_rcu(rd, rcu);
 825                 goto out;
 826         }
 827
 828         vxlan_fdb_destroy(vxlan, f);
 829
 830 out:
 831         spin_unlock_bh(&vxlan->hash_lock);
 832
 833         return err;
 834 }
 835
 836 /* Dump forwarding table */
 837 static int vxlan_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
 838                           struct net_device *dev, int idx)
 839 {
 840         struct vxlan_dev *vxlan = netdev_priv(dev);
 841         unsigned int h;
 842
 843         for (h = 0; h < FDB_HASH_SIZE; ++h) {
 844                 struct vxlan_fdb *f;
 845                 int err;
 846
 847                 hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
 848                         struct vxlan_rdst *rd;
 849
 850                         if (idx < cb->args[0])
 851                                 goto skip;
 852
 853                         list_for_each_entry_rcu(rd, &f->remotes, list) {
 854                                 err = vxlan_fdb_info(skb, vxlan, f,
 855                                                      NETLINK_CB(cb->skb).portid,
 856                                                      cb->nlh->nlmsg_seq,
 857                                                      RTM_NEWNEIGH,
 858                                                      NLM_F_MULTI, rd);
 859                                 if (err < 0)
 860                                         goto out;
 861                         }
 862 skip:
 863                         ++idx;
 864                 }
 865         }
 866 out:
 867         return idx;
 868 }
 869
 870 /* Watch incoming packets to learn mapping between Ethernet address
 871  * and Tunnel endpoint.
 872  * Return true if packet is bogus and should be droppped.
 873  */
 874 static bool vxlan_snoop(struct net_device *dev,
 875                         union vxlan_addr *src_ip, const u8 *src_mac)
 876 {
 877         struct vxlan_dev *vxlan = netdev_priv(dev);
 878         struct vxlan_fdb *f;
 879
 880         f = vxlan_find_mac(vxlan, src_mac);
 881         if (likely(f)) {
 882                 struct vxlan_rdst *rdst = first_remote_rcu(f);
 883
 884                 if (likely(vxlan_addr_equal(&rdst->remote_ip, src_ip)))
 885                         return false;
 886
 887                 /* Don't migrate static entries, drop packets */
 888                 if (f->state & NUD_NOARP)
 889                         return true;
 890
 891                 if (net_ratelimit())
 892                         netdev_info(dev,
 893                                     "%pM migrated from %pIS to %pIS\n",
 894                                     src_mac, &rdst->remote_ip, &src_ip);
 895
 896                 rdst->remote_ip = *src_ip;
 897                 f->updated = jiffies;
 898                 vxlan_fdb_notify(vxlan, f, RTM_NEWNEIGH);
 899         } else {
 900                 /* learned new entry */
 901                 spin_lock(&vxlan->hash_lock);
 902
 903                 /* close off race between vxlan_flush and incoming packets */
 904                 if (netif_running(dev))
 905                         vxlan_fdb_create(vxlan, src_mac, src_ip,
 906                                          NUD_REACHABLE,
 907                                          NLM_F_EXCL|NLM_F_CREATE,
 908                                          vxlan->dst_port,
 909                                          vxlan->default_dst.remote_vni,
 910                                          0, NTF_SELF);
 911                 spin_unlock(&vxlan->hash_lock);
 912         }
 913
 914         return false;
 915 }
 916
 917 /* See if multicast group is already in use by other ID */
 918 static bool vxlan_group_used(struct vxlan_net *vn, struct vxlan_dev *dev)
 919 {
 920         struct vxlan_dev *vxlan;
 921
 922         /* The vxlan_sock is only used by dev, leaving group has
 923          * no effect on other vxlan devices.
 924          */
 925         if (atomic_read(&dev->vn_sock->refcnt) == 1)
 926                 return false;
 927
 928         list_for_each_entry(vxlan, &vn->vxlan_list, next) {
 929                 if (!netif_running(vxlan->dev) || vxlan == dev)
 930                         continue;
 931
 932                 if (vxlan->vn_sock != dev->vn_sock)
 933                         continue;
 934
 935                 if (!vxlan_addr_equal(&vxlan->default_dst.remote_ip,
 936                                       &dev->default_dst.remote_ip))
 937                         continue;
 938
 939                 if (vxlan->default_dst.remote_ifindex !=
 940                     dev->default_dst.remote_ifindex)
 941                         continue;
 942
 943                 return true;
 944         }
 945
 946         return false;
 947 }
 948
 949 static void vxlan_sock_hold(struct vxlan_sock *vs)
 950 {
 951         atomic_inc(&vs->refcnt);
 952 }
 953
 954 void vxlan_sock_release(struct vxlan_sock *vs)
 955 {
 956         struct sock *sk = vs->sock->sk;
 957         struct net *net = sock_net(sk);
 958         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
 959
 960         if (!atomic_dec_and_test(&vs->refcnt))
 961                 return;
 962
 963         spin_lock(&vn->sock_lock);
 964         hlist_del_rcu(&vs->hlist);
 965         rcu_assign_sk_user_data(vs->sock->sk, NULL);
 966         vxlan_notify_del_rx_port(sk);
 967         spin_unlock(&vn->sock_lock);
 968
 969         queue_work(vxlan_wq, &vs->del_work);
 970 }
 971 EXPORT_SYMBOL_GPL(vxlan_sock_release);
 972
 973 /* Callback to update multicast group membership when first VNI on
 974  * multicast asddress is brought up
 975  * Done as workqueue because ip_mc_join_group acquires RTNL.
 976  */
 977 static void vxlan_igmp_join(struct work_struct *work)
 978 {
 979         struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_join);
 980         struct vxlan_sock *vs = vxlan->vn_sock;
 981         struct sock *sk = vs->sock->sk;
 982         union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
 983         int ifindex = vxlan->default_dst.remote_ifindex;
 984
 985         lock_sock(sk);
 986         if (ip->sa.sa_family == AF_INET) {
 987                 struct ip_mreqn mreq = {
 988                         .imr_multiaddr.s_addr   = ip->sin.sin_addr.s_addr,
 989                         .imr_ifindex            = ifindex,
 990                 };
 991
 992                 ip_mc_join_group(sk, &mreq);
 993 #if IS_ENABLED(CONFIG_IPV6)
 994         } else {
 995                 ipv6_stub->ipv6_sock_mc_join(sk, ifindex,
 996                                              &ip->sin6.sin6_addr);
 997 #endif
 998         }
 999         release_sock(sk);
1000
1001         vxlan_sock_release(vs);
1002         dev_put(vxlan->dev);
1003 }
1004
1005 /* Inverse of vxlan_igmp_join when last VNI is brought down */
1006 static void vxlan_igmp_leave(struct work_struct *work)
1007 {
1008         struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, igmp_leave);
1009         struct vxlan_sock *vs = vxlan->vn_sock;
1010         struct sock *sk = vs->sock->sk;
1011         union vxlan_addr *ip = &vxlan->default_dst.remote_ip;
1012         int ifindex = vxlan->default_dst.remote_ifindex;
1013
1014         lock_sock(sk);
1015         if (ip->sa.sa_family == AF_INET) {
1016                 struct ip_mreqn mreq = {
1017                         .imr_multiaddr.s_addr   = ip->sin.sin_addr.s_addr,
1018                         .imr_ifindex            = ifindex,
1019                 };
1020
1021                 ip_mc_leave_group(sk, &mreq);
1022 #if IS_ENABLED(CONFIG_IPV6)
1023         } else {
1024                 ipv6_stub->ipv6_sock_mc_drop(sk, ifindex,
1025                                              &ip->sin6.sin6_addr);
1026 #endif
1027         }
1028
1029         release_sock(sk);
1030
1031         vxlan_sock_release(vs);
1032         dev_put(vxlan->dev);
1033 }
1034
1035 /* Callback from net/ipv4/udp.c to receive packets */
1036 static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
1037 {
1038         struct vxlan_sock *vs;
1039         struct vxlanhdr *vxh;
1040         __be16 port;
1041
1042         /* Need Vxlan and inner Ethernet header to be present */
1043         if (!pskb_may_pull(skb, VXLAN_HLEN))
1044                 goto error;
1045
1046         /* Return packets with reserved bits set */
1047         vxh = (struct vxlanhdr *)(udp_hdr(skb) + 1);
1048         if (vxh->vx_flags != htonl(VXLAN_FLAGS) ||
1049             (vxh->vx_vni & htonl(0xff))) {
1050                 netdev_dbg(skb->dev, "invalid vxlan flags=%#x vni=%#x\n",
1051                            ntohl(vxh->vx_flags), ntohl(vxh->vx_vni));
1052                 goto error;
1053         }
1054
1055         if (iptunnel_pull_header(skb, VXLAN_HLEN, htons(ETH_P_TEB)))
1056                 goto drop;
1057
1058         port = inet_sk(sk)->inet_sport;
1059
1060         vs = rcu_dereference_sk_user_data(sk);
1061         if (!vs)
1062                 goto drop;
1063
1064         vs->rcv(vs, skb, vxh->vx_vni);
1065         return 0;
1066
1067 drop:
1068         /* Consume bad packet */
1069         kfree_skb(skb);
1070         return 0;
1071
1072 error:
1073         /* Return non vxlan pkt */
1074         return 1;
1075 }
1076
1077 static void vxlan_rcv(struct vxlan_sock *vs,
1078                       struct sk_buff *skb, __be32 vx_vni)
1079 {
1080         struct iphdr *oip = NULL;
1081         struct ipv6hdr *oip6 = NULL;
1082         struct vxlan_dev *vxlan;
1083         struct pcpu_sw_netstats *stats;
1084         union vxlan_addr saddr;
1085         __u32 vni;
1086         int err = 0;
1087         union vxlan_addr *remote_ip;
1088
1089         vni = ntohl(vx_vni) >> 8;
1090         /* Is this VNI defined? */
1091         vxlan = vxlan_vs_find_vni(vs, vni);
1092         if (!vxlan)
1093                 goto drop;
1094
1095         remote_ip = &vxlan->default_dst.remote_ip;
1096         skb_reset_mac_header(skb);
1097         skb->protocol = eth_type_trans(skb, vxlan->dev);
1098
1099         /* Ignore packet loops (and multicast echo) */
1100         if (ether_addr_equal(eth_hdr(skb)->h_source, vxlan->dev->dev_addr))
1101                 goto drop;
1102
1103         /* Re-examine inner Ethernet packet */
1104         if (remote_ip->sa.sa_family == AF_INET) {
1105                 oip = ip_hdr(skb);
1106                 saddr.sin.sin_addr.s_addr = oip->saddr;
1107                 saddr.sa.sa_family = AF_INET;
1108 #if IS_ENABLED(CONFIG_IPV6)
1109         } else {
1110                 oip6 = ipv6_hdr(skb);
1111                 saddr.sin6.sin6_addr = oip6->saddr;
1112                 saddr.sa.sa_family = AF_INET6;
1113 #endif
1114         }
1115
1116         if ((vxlan->flags & VXLAN_F_LEARN) &&
1117             vxlan_snoop(skb->dev, &saddr, eth_hdr(skb)->h_source))
1118                 goto drop;
1119
1120         skb_reset_network_header(skb);
1121
1122         /* If the NIC driver gave us an encapsulated packet with
1123          * CHECKSUM_UNNECESSARY and Rx checksum feature is enabled,
1124          * leave the CHECKSUM_UNNECESSARY, the device checksummed it
1125          * for us. Otherwise force the upper layers to verify it.
1126          */
1127         if (skb->ip_summed != CHECKSUM_UNNECESSARY || !skb->encapsulation ||
1128             !(vxlan->dev->features & NETIF_F_RXCSUM))
1129                 skb->ip_summed = CHECKSUM_NONE;
1130
1131         skb->encapsulation = 0;
1132
1133         if (oip6)
1134                 err = IP6_ECN_decapsulate(oip6, skb);
1135         if (oip)
1136                 err = IP_ECN_decapsulate(oip, skb);
1137
1138         if (unlikely(err)) {
1139                 if (log_ecn_error) {
1140                         if (oip6)
1141                                 net_info_ratelimited("non-ECT from %pI6\n",
1142                                                      &oip6->saddr);
1143                         if (oip)
1144                                 net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
1145                                                      &oip->saddr, oip->tos);
1146                 }
1147                 if (err > 1) {
1148                         ++vxlan->dev->stats.rx_frame_errors;
1149                         ++vxlan->dev->stats.rx_errors;
1150                         goto drop;
1151                 }
1152         }
1153
1154         stats = this_cpu_ptr(vxlan->dev->tstats);
1155         u64_stats_update_begin(&stats->syncp);
1156         stats->rx_packets++;
1157         stats->rx_bytes += skb->len;
1158         u64_stats_update_end(&stats->syncp);
1159
1160         netif_rx(skb);
1161
1162         return;
1163 drop:
1164         /* Consume bad packet */
1165         kfree_skb(skb);
1166 }
1167
1168 static int arp_reduce(struct net_device *dev, struct sk_buff *skb)
1169 {
1170         struct vxlan_dev *vxlan = netdev_priv(dev);
1171         struct arphdr *parp;
1172         u8 *arpptr, *sha;
1173         __be32 sip, tip;
1174         struct neighbour *n;
1175
1176         if (dev->flags & IFF_NOARP)
1177                 goto out;
1178
1179         if (!pskb_may_pull(skb, arp_hdr_len(dev))) {
1180                 dev->stats.tx_dropped++;
1181                 goto out;
1182         }
1183         parp = arp_hdr(skb);
1184
1185         if ((parp->ar_hrd != htons(ARPHRD_ETHER) &&
1186              parp->ar_hrd != htons(ARPHRD_IEEE802)) ||
1187             parp->ar_pro != htons(ETH_P_IP) ||
1188             parp->ar_op != htons(ARPOP_REQUEST) ||
1189             parp->ar_hln != dev->addr_len ||
1190             parp->ar_pln != 4)
1191                 goto out;
1192         arpptr = (u8 *)parp + sizeof(struct arphdr);
1193         sha = arpptr;
1194         arpptr += dev->addr_len;        /* sha */
1195         memcpy(&sip, arpptr, sizeof(sip));
1196         arpptr += sizeof(sip);
1197         arpptr += dev->addr_len;        /* tha */
1198         memcpy(&tip, arpptr, sizeof(tip));
1199
1200         if (ipv4_is_loopback(tip) ||
1201             ipv4_is_multicast(tip))
1202                 goto out;
1203
1204         n = neigh_lookup(&arp_tbl, &tip, dev);
1205
1206         if (n) {
1207                 struct vxlan_fdb *f;
1208                 struct sk_buff  *reply;
1209
1210                 if (!(n->nud_state & NUD_CONNECTED)) {
1211                         neigh_release(n);
1212                         goto out;
1213                 }
1214
1215                 f = vxlan_find_mac(vxlan, n->ha);
1216                 if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
1217                         /* bridge-local neighbor */
1218                         neigh_release(n);
1219                         goto out;
1220                 }
1221
1222                 reply = arp_create(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
1223                                 n->ha, sha);
1224
1225                 neigh_release(n);
1226
1227                 skb_reset_mac_header(reply);
1228                 __skb_pull(reply, skb_network_offset(reply));
1229                 reply->ip_summed = CHECKSUM_UNNECESSARY;
1230                 reply->pkt_type = PACKET_HOST;
1231
1232                 if (netif_rx_ni(reply) == NET_RX_DROP)
1233                         dev->stats.rx_dropped++;
1234         } else if (vxlan->flags & VXLAN_F_L3MISS) {
1235                 union vxlan_addr ipa = {
1236                         .sin.sin_addr.s_addr = tip,
1237                         .sa.sa_family = AF_INET,
1238                 };
1239
1240                 vxlan_ip_miss(dev, &ipa);
1241         }
1242 out:
1243         consume_skb(skb);
1244         return NETDEV_TX_OK;
1245 }
1246
1247 #if IS_ENABLED(CONFIG_IPV6)
1248 static int neigh_reduce(struct net_device *dev, struct sk_buff *skb)
1249 {
1250         struct vxlan_dev *vxlan = netdev_priv(dev);
1251         struct neighbour *n;
1252         union vxlan_addr ipa;
1253         const struct ipv6hdr *iphdr;
1254         const struct in6_addr *saddr, *daddr;
1255         struct nd_msg *msg;
1256         struct inet6_dev *in6_dev = NULL;
1257
1258         in6_dev = __in6_dev_get(dev);
1259         if (!in6_dev)
1260                 goto out;
1261
1262         if (!pskb_may_pull(skb, skb->len))
1263                 goto out;
1264
1265         iphdr = ipv6_hdr(skb);
1266         saddr = &iphdr->saddr;
1267         daddr = &iphdr->daddr;
1268
1269         if (ipv6_addr_loopback(daddr) ||
1270             ipv6_addr_is_multicast(daddr))
1271                 goto out;
1272
1273         msg = (struct nd_msg *)skb_transport_header(skb);
1274         if (msg->icmph.icmp6_code != 0 ||
1275             msg->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION)
1276                 goto out;
1277
1278         n = neigh_lookup(ipv6_stub->nd_tbl, daddr, dev);
1279
1280         if (n) {
1281                 struct vxlan_fdb *f;
1282
1283                 if (!(n->nud_state & NUD_CONNECTED)) {
1284                         neigh_release(n);
1285                         goto out;
1286                 }
1287
1288                 f = vxlan_find_mac(vxlan, n->ha);
1289                 if (f && vxlan_addr_any(&(first_remote_rcu(f)->remote_ip))) {
1290                         /* bridge-local neighbor */
1291                         neigh_release(n);
1292                         goto out;
1293                 }
1294
1295                 ipv6_stub->ndisc_send_na(dev, n, saddr, &msg->target,
1296                                          !!in6_dev->cnf.forwarding,
1297                                          true, false, false);
1298                 neigh_release(n);
1299         } else if (vxlan->flags & VXLAN_F_L3MISS) {
1300                 ipa.sin6.sin6_addr = *daddr;
1301                 ipa.sa.sa_family = AF_INET6;
1302                 vxlan_ip_miss(dev, &ipa);
1303         }
1304
1305 out:
1306         consume_skb(skb);
1307         return NETDEV_TX_OK;
1308 }
1309 #endif
1310
1311 static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)
1312 {
1313         struct vxlan_dev *vxlan = netdev_priv(dev);
1314         struct neighbour *n;
1315
1316         if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))
1317                 return false;
1318
1319         n = NULL;
1320         switch (ntohs(eth_hdr(skb)->h_proto)) {
1321         case ETH_P_IP:
1322         {
1323                 struct iphdr *pip;
1324
1325                 if (!pskb_may_pull(skb, sizeof(struct iphdr)))
1326                         return false;
1327                 pip = ip_hdr(skb);
1328                 n = neigh_lookup(&arp_tbl, &pip->daddr, dev);
1329                 if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
1330                         union vxlan_addr ipa = {
1331                                 .sin.sin_addr.s_addr = pip->daddr,
1332                                 .sa.sa_family = AF_INET,
1333                         };
1334
1335                         vxlan_ip_miss(dev, &ipa);
1336                         return false;
1337                 }
1338
1339                 break;
1340         }
1341 #if IS_ENABLED(CONFIG_IPV6)
1342         case ETH_P_IPV6:
1343         {
1344                 struct ipv6hdr *pip6;
1345
1346                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
1347                         return false;
1348                 pip6 = ipv6_hdr(skb);
1349                 n = neigh_lookup(ipv6_stub->nd_tbl, &pip6->daddr, dev);
1350                 if (!n && (vxlan->flags & VXLAN_F_L3MISS)) {
1351                         union vxlan_addr ipa = {
1352                                 .sin6.sin6_addr = pip6->daddr,
1353                                 .sa.sa_family = AF_INET6,
1354                         };
1355
1356                         vxlan_ip_miss(dev, &ipa);
1357                         return false;
1358                 }
1359
1360                 break;
1361         }
1362 #endif
1363         default:
1364                 return false;
1365         }
1366
1367         if (n) {
1368                 bool diff;
1369
1370                 diff = !ether_addr_equal(eth_hdr(skb)->h_dest, n->ha);
1371                 if (diff) {
1372                         memcpy(eth_hdr(skb)->h_source, eth_hdr(skb)->h_dest,
1373                                 dev->addr_len);
1374                         memcpy(eth_hdr(skb)->h_dest, n->ha, dev->addr_len);
1375                 }
1376                 neigh_release(n);
1377                 return diff;
1378         }
1379
1380         return false;
1381 }
1382
1383 /* Compute source port for outgoing packet
1384  *   first choice to use L4 flow hash since it will spread
1385  *     better and maybe available from hardware
1386  *   secondary choice is to use jhash on the Ethernet header
1387  */
1388 __be16 vxlan_src_port(__u16 port_min, __u16 port_max, struct sk_buff *skb)
1389 {
1390         unsigned int range = (port_max - port_min) + 1;
1391         u32 hash;
1392
1393         hash = skb_get_hash(skb);
1394         if (!hash)
1395                 hash = jhash(skb->data, 2 * ETH_ALEN,
1396                              (__force u32) skb->protocol);
1397
1398         return htons((((u64) hash * range) >> 32) + port_min);
1399 }
1400 EXPORT_SYMBOL_GPL(vxlan_src_port);
1401
1402 static int handle_offloads(struct sk_buff *skb)
1403 {
1404         if (skb_is_gso(skb)) {
1405                 int err = skb_unclone(skb, GFP_ATOMIC);
1406                 if (unlikely(err))
1407                         return err;
1408
1409                 skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
1410         } else if (skb->ip_summed != CHECKSUM_PARTIAL)
1411                 skb->ip_summed = CHECKSUM_NONE;
1412
1413         return 0;
1414 }
1415
1416 #if IS_ENABLED(CONFIG_IPV6)
1417 static int vxlan6_xmit_skb(struct vxlan_sock *vs,
1418                            struct dst_entry *dst, struct sk_buff *skb,
1419                            struct net_device *dev, struct in6_addr *saddr,
1420                            struct in6_addr *daddr, __u8 prio, __u8 ttl,
1421                            __be16 src_port, __be16 dst_port, __be32 vni)
1422 {
1423         struct ipv6hdr *ip6h;
1424         struct vxlanhdr *vxh;
1425         struct udphdr *uh;
1426         int min_headroom;
1427         int err;
1428
1429         if (!skb->encapsulation) {
1430                 skb_reset_inner_headers(skb);
1431                 skb->encapsulation = 1;
1432         }
1433
1434         skb_scrub_packet(skb, false);
1435
1436         min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len
1437                         + VXLAN_HLEN + sizeof(struct ipv6hdr)
1438                         + (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);
1439
1440         /* Need space for new headers (invalidates iph ptr) */
1441         err = skb_cow_head(skb, min_headroom);
1442         if (unlikely(err))
1443                 return err;
1444
1445         if (vlan_tx_tag_present(skb)) {
1446                 if (WARN_ON(!__vlan_put_tag(skb,
1447                                             skb->vlan_proto,
1448                                             vlan_tx_tag_get(skb))))
1449                         return -ENOMEM;
1450
1451                 skb->vlan_tci = 0;
1452         }
1453
1454         vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
1455         vxh->vx_flags = htonl(VXLAN_FLAGS);
1456         vxh->vx_vni = vni;
1457
1458         __skb_push(skb, sizeof(*uh));
1459         skb_reset_transport_header(skb);
1460         uh = udp_hdr(skb);
1461
1462         uh->dest = dst_port;
1463         uh->source = src_port;
1464
1465         uh->len = htons(skb->len);
1466         uh->check = 0;
1467
1468         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1469         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
1470                               IPSKB_REROUTED);
1471         skb_dst_set(skb, dst);
1472
1473         if (!skb_is_gso(skb) && !(dst->dev->features & NETIF_F_IPV6_CSUM)) {
1474                 __wsum csum = skb_checksum(skb, 0, skb->len, 0);
1475                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1476                 uh->check = csum_ipv6_magic(saddr, daddr, skb->len,
1477                                             IPPROTO_UDP, csum);
1478                 if (uh->check == 0)
1479                         uh->check = CSUM_MANGLED_0;
1480         } else {
1481                 skb->ip_summed = CHECKSUM_PARTIAL;
1482                 skb->csum_start = skb_transport_header(skb) - skb->head;
1483                 skb->csum_offset = offsetof(struct udphdr, check);
1484                 uh->check = ~csum_ipv6_magic(saddr, daddr,
1485                                              skb->len, IPPROTO_UDP, 0);
1486         }
1487
1488         __skb_push(skb, sizeof(*ip6h));
1489         skb_reset_network_header(skb);
1490         ip6h              = ipv6_hdr(skb);
1491         ip6h->version     = 6;
1492         ip6h->priority    = prio;
1493         ip6h->flow_lbl[0] = 0;
1494         ip6h->flow_lbl[1] = 0;
1495         ip6h->flow_lbl[2] = 0;
1496         ip6h->payload_len = htons(skb->len);
1497         ip6h->nexthdr     = IPPROTO_UDP;
1498         ip6h->hop_limit   = ttl;
1499         ip6h->daddr       = *daddr;
1500         ip6h->saddr       = *saddr;
1501
1502         err = handle_offloads(skb);
1503         if (err)
1504                 return err;
1505
1506         ip6tunnel_xmit(skb, dev);
1507         return 0;
1508 }
1509 #endif
1510
1511 int vxlan_xmit_skb(struct vxlan_sock *vs,
1512                    struct rtable *rt, struct sk_buff *skb,
1513                    __be32 src, __be32 dst, __u8 tos, __u8 ttl, __be16 df,
1514                    __be16 src_port, __be16 dst_port, __be32 vni)
1515 {
1516         struct vxlanhdr *vxh;
1517         struct udphdr *uh;
1518         int min_headroom;
1519         int err;
1520
1521         if (!skb->encapsulation) {
1522                 skb_reset_inner_headers(skb);
1523                 skb->encapsulation = 1;
1524         }
1525
1526         min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
1527                         + VXLAN_HLEN + sizeof(struct iphdr)
1528                         + (vlan_tx_tag_present(skb) ? VLAN_HLEN : 0);
1529
1530         /* Need space for new headers (invalidates iph ptr) */
1531         err = skb_cow_head(skb, min_headroom);
1532         if (unlikely(err))
1533                 return err;
1534
1535         if (vlan_tx_tag_present(skb)) {
1536                 if (WARN_ON(!__vlan_put_tag(skb,
1537                                             skb->vlan_proto,
1538                                             vlan_tx_tag_get(skb))))
1539                         return -ENOMEM;
1540
1541                 skb->vlan_tci = 0;
1542         }
1543
1544         vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh));
1545         vxh->vx_flags = htonl(VXLAN_FLAGS);
1546         vxh->vx_vni = vni;
1547
1548         __skb_push(skb, sizeof(*uh));
1549         skb_reset_transport_header(skb);
1550         uh = udp_hdr(skb);
1551
1552         uh->dest = dst_port;
1553         uh->source = src_port;
1554
1555         uh->len = htons(skb->len);
1556         uh->check = 0;
1557
1558         err = handle_offloads(skb);
1559         if (err)
1560                 return err;
1561
1562         return iptunnel_xmit(rt, skb, src, dst, IPPROTO_UDP, tos, ttl, df,
1563                              false);
1564 }
1565 EXPORT_SYMBOL_GPL(vxlan_xmit_skb);
1566
1567 /* Bypass encapsulation if the destination is local */
1568 static void vxlan_encap_bypass(struct sk_buff *skb, struct vxlan_dev *src_vxlan,
1569                                struct vxlan_dev *dst_vxlan)
1570 {
1571         struct pcpu_sw_netstats *tx_stats, *rx_stats;
1572         union vxlan_addr loopback;
1573         union vxlan_addr *remote_ip = &dst_vxlan->default_dst.remote_ip;
1574
1575         tx_stats = this_cpu_ptr(src_vxlan->dev->tstats);
1576         rx_stats = this_cpu_ptr(dst_vxlan->dev->tstats);
1577         skb->pkt_type = PACKET_HOST;
1578         skb->encapsulation = 0;
1579         skb->dev = dst_vxlan->dev;
1580         __skb_pull(skb, skb_network_offset(skb));
1581
1582         if (remote_ip->sa.sa_family == AF_INET) {
1583                 loopback.sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1584                 loopback.sa.sa_family =  AF_INET;
1585 #if IS_ENABLED(CONFIG_IPV6)
1586         } else {
1587                 loopback.sin6.sin6_addr = in6addr_loopback;
1588                 loopback.sa.sa_family =  AF_INET6;
1589 #endif
1590         }
1591
1592         if (dst_vxlan->flags & VXLAN_F_LEARN)
1593                 vxlan_snoop(skb->dev, &loopback, eth_hdr(skb)->h_source);
1594
1595         u64_stats_update_begin(&tx_stats->syncp);
1596         tx_stats->tx_packets++;
1597         tx_stats->tx_bytes += skb->len;
1598         u64_stats_update_end(&tx_stats->syncp);
1599
1600         if (netif_rx(skb) == NET_RX_SUCCESS) {
1601                 u64_stats_update_begin(&rx_stats->syncp);
1602                 rx_stats->rx_packets++;
1603                 rx_stats->rx_bytes += skb->len;
1604                 u64_stats_update_end(&rx_stats->syncp);
1605         } else {
1606                 skb->dev->stats.rx_dropped++;
1607         }
1608 }
1609
1610 static void vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
1611                            struct vxlan_rdst *rdst, bool did_rsc)
1612 {
1613         struct vxlan_dev *vxlan = netdev_priv(dev);
1614         struct rtable *rt = NULL;
1615         const struct iphdr *old_iph;
1616         struct flowi4 fl4;
1617         union vxlan_addr *dst;
1618         __be16 src_port = 0, dst_port;
1619         u32 vni;
1620         __be16 df = 0;
1621         __u8 tos, ttl;
1622         int err;
1623
1624         dst_port = rdst->remote_port ? rdst->remote_port : vxlan->dst_port;
1625         vni = rdst->remote_vni;
1626         dst = &rdst->remote_ip;
1627
1628         if (vxlan_addr_any(dst)) {
1629                 if (did_rsc) {
1630                         /* short-circuited back to local bridge */
1631                         vxlan_encap_bypass(skb, vxlan, vxlan);
1632                         return;
1633                 }
1634                 goto drop;
1635         }
1636
1637         old_iph = ip_hdr(skb);
1638
1639         ttl = vxlan->ttl;
1640         if (!ttl && vxlan_addr_multicast(dst))
1641                 ttl = 1;
1642
1643         tos = vxlan->tos;
1644         if (tos == 1)
1645                 tos = ip_tunnel_get_dsfield(old_iph, skb);
1646
1647         src_port = vxlan_src_port(vxlan->port_min, vxlan->port_max, skb);
1648
1649         if (dst->sa.sa_family == AF_INET) {
1650                 memset(&fl4, 0, sizeof(fl4));
1651                 fl4.flowi4_oif = rdst->remote_ifindex;
1652                 fl4.flowi4_tos = RT_TOS(tos);
1653                 fl4.daddr = dst->sin.sin_addr.s_addr;
1654                 fl4.saddr = vxlan->saddr.sin.sin_addr.s_addr;
1655
1656                 rt = ip_route_output_key(dev_net(dev), &fl4);
1657                 if (IS_ERR(rt)) {
1658                         netdev_dbg(dev, "no route to %pI4\n",
1659                                    &dst->sin.sin_addr.s_addr);
1660                         dev->stats.tx_carrier_errors++;
1661                         goto tx_error;
1662                 }
1663
1664                 if (rt->dst.dev == dev) {
1665                         netdev_dbg(dev, "circular route to %pI4\n",
1666                                    &dst->sin.sin_addr.s_addr);
1667                         dev->stats.collisions++;
1668                         goto rt_tx_error;
1669                 }
1670
1671                 /* Bypass encapsulation if the destination is local */
1672                 if (rt->rt_flags & RTCF_LOCAL &&
1673                     !(rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
1674                         struct vxlan_dev *dst_vxlan;
1675
1676                         ip_rt_put(rt);
1677                         dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);
1678                         if (!dst_vxlan)
1679                                 goto tx_error;
1680                         vxlan_encap_bypass(skb, vxlan, dst_vxlan);
1681                         return;
1682                 }
1683
1684                 tos = ip_tunnel_ecn_encap(tos, old_iph, skb);
1685                 ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
1686
1687                 err = vxlan_xmit_skb(vxlan->vn_sock, rt, skb,
1688                                      fl4.saddr, dst->sin.sin_addr.s_addr,
1689                                      tos, ttl, df, src_port, dst_port,
1690                                      htonl(vni << 8));
1691
1692                 if (err < 0)
1693                         goto rt_tx_error;
1694                 iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
1695 #if IS_ENABLED(CONFIG_IPV6)
1696         } else {
1697                 struct sock *sk = vxlan->vn_sock->sock->sk;
1698                 struct dst_entry *ndst;
1699                 struct flowi6 fl6;
1700                 u32 flags;
1701
1702                 memset(&fl6, 0, sizeof(fl6));
1703                 fl6.flowi6_oif = rdst->remote_ifindex;
1704                 fl6.daddr = dst->sin6.sin6_addr;
1705                 fl6.saddr = vxlan->saddr.sin6.sin6_addr;
1706                 fl6.flowi6_proto = IPPROTO_UDP;
1707
1708                 if (ipv6_stub->ipv6_dst_lookup(sk, &ndst, &fl6)) {
1709                         netdev_dbg(dev, "no route to %pI6\n",
1710                                    &dst->sin6.sin6_addr);
1711                         dev->stats.tx_carrier_errors++;
1712                         goto tx_error;
1713                 }
1714
1715                 if (ndst->dev == dev) {
1716                         netdev_dbg(dev, "circular route to %pI6\n",
1717                                    &dst->sin6.sin6_addr);
1718                         dst_release(ndst);
1719                         dev->stats.collisions++;
1720                         goto tx_error;
1721                 }
1722
1723                 /* Bypass encapsulation if the destination is local */
1724                 flags = ((struct rt6_info *)ndst)->rt6i_flags;
1725                 if (flags & RTF_LOCAL &&
1726                     !(flags & (RTCF_BROADCAST | RTCF_MULTICAST))) {
1727                         struct vxlan_dev *dst_vxlan;
1728
1729                         dst_release(ndst);
1730                         dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);
1731                         if (!dst_vxlan)
1732                                 goto tx_error;
1733                         vxlan_encap_bypass(skb, vxlan, dst_vxlan);
1734                         return;
1735                 }
1736
1737                 ttl = ttl ? : ip6_dst_hoplimit(ndst);
1738
1739                 err = vxlan6_xmit_skb(vxlan->vn_sock, ndst, skb,
1740                                       dev, &fl6.saddr, &fl6.daddr, 0, ttl,
1741                                       src_port, dst_port, htonl(vni << 8));
1742 #endif
1743         }
1744
1745         return;
1746
1747 drop:
1748         dev->stats.tx_dropped++;
1749         goto tx_free;
1750
1751 rt_tx_error:
1752         ip_rt_put(rt);
1753 tx_error:
1754         dev->stats.tx_errors++;
1755 tx_free:
1756         dev_kfree_skb(skb);
1757 }
1758
1759 /* Transmit local packets over Vxlan
1760  *
1761  * Outer IP header inherits ECN and DF from inner header.
1762  * Outer UDP destination is the VXLAN assigned port.
1763  *           source port is based on hash of flow
1764  */
1765 static netdev_tx_t vxlan_xmit(struct sk_buff *skb, struct net_device *dev)
1766 {
1767         struct vxlan_dev *vxlan = netdev_priv(dev);
1768         struct ethhdr *eth;
1769         bool did_rsc = false;
1770         struct vxlan_rdst *rdst, *fdst = NULL;
1771         struct vxlan_fdb *f;
1772
1773         skb_reset_mac_header(skb);
1774         eth = eth_hdr(skb);
1775
1776         if ((vxlan->flags & VXLAN_F_PROXY)) {
1777                 if (ntohs(eth->h_proto) == ETH_P_ARP)
1778                         return arp_reduce(dev, skb);
1779 #if IS_ENABLED(CONFIG_IPV6)
1780                 else if (ntohs(eth->h_proto) == ETH_P_IPV6 &&
1781                          skb->len >= sizeof(struct ipv6hdr) + sizeof(struct nd_msg) &&
1782                          ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {
1783                                 struct nd_msg *msg;
1784
1785                                 msg = (struct nd_msg *)skb_transport_header(skb);
1786                                 if (msg->icmph.icmp6_code == 0 &&
1787                                     msg->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION)
1788                                         return neigh_reduce(dev, skb);
1789                 }
1790 #endif
1791         }
1792
1793         f = vxlan_find_mac(vxlan, eth->h_dest);
1794         did_rsc = false;
1795
1796         if (f && (f->flags & NTF_ROUTER) && (vxlan->flags & VXLAN_F_RSC) &&
1797             (ntohs(eth->h_proto) == ETH_P_IP ||
1798              ntohs(eth->h_proto) == ETH_P_IPV6)) {
1799                 did_rsc = route_shortcircuit(dev, skb);
1800                 if (did_rsc)
1801                         f = vxlan_find_mac(vxlan, eth->h_dest);
1802         }
1803
1804         if (f == NULL) {
1805                 f = vxlan_find_mac(vxlan, all_zeros_mac);
1806                 if (f == NULL) {
1807                         if ((vxlan->flags & VXLAN_F_L2MISS) &&
1808                             !is_multicast_ether_addr(eth->h_dest))
1809                                 vxlan_fdb_miss(vxlan, eth->h_dest);
1810
1811                         dev->stats.tx_dropped++;
1812                         kfree_skb(skb);
1813                         return NETDEV_TX_OK;
1814                 }
1815         }
1816
1817         list_for_each_entry_rcu(rdst, &f->remotes, list) {
1818                 struct sk_buff *skb1;
1819
1820                 if (!fdst) {
1821                         fdst = rdst;
1822                         continue;
1823                 }
1824                 skb1 = skb_clone(skb, GFP_ATOMIC);
1825                 if (skb1)
1826                         vxlan_xmit_one(skb1, dev, rdst, did_rsc);
1827         }
1828
1829         if (fdst)
1830                 vxlan_xmit_one(skb, dev, fdst, did_rsc);
1831         else
1832                 kfree_skb(skb);
1833         return NETDEV_TX_OK;
1834 }
1835
1836 /* Walk the forwarding table and purge stale entries */
1837 static void vxlan_cleanup(unsigned long arg)
1838 {
1839         struct vxlan_dev *vxlan = (struct vxlan_dev *) arg;
1840         unsigned long next_timer = jiffies + FDB_AGE_INTERVAL;
1841         unsigned int h;
1842
1843         if (!netif_running(vxlan->dev))
1844                 return;
1845
1846         spin_lock_bh(&vxlan->hash_lock);
1847         for (h = 0; h < FDB_HASH_SIZE; ++h) {
1848                 struct hlist_node *p, *n;
1849                 hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
1850                         struct vxlan_fdb *f
1851                                 = container_of(p, struct vxlan_fdb, hlist);
1852                         unsigned long timeout;
1853
1854                         if (f->state & NUD_PERMANENT)
1855                                 continue;
1856
1857                         timeout = f->used + vxlan->age_interval * HZ;
1858                         if (time_before_eq(timeout, jiffies)) {
1859                                 netdev_dbg(vxlan->dev,
1860                                            "garbage collect %pM\n",
1861                                            f->eth_addr);
1862                                 f->state = NUD_STALE;
1863                                 vxlan_fdb_destroy(vxlan, f);
1864                         } else if (time_before(timeout, next_timer))
1865                                 next_timer = timeout;
1866                 }
1867         }
1868         spin_unlock_bh(&vxlan->hash_lock);
1869
1870         mod_timer(&vxlan->age_timer, next_timer);
1871 }
1872
1873 static void vxlan_vs_add_dev(struct vxlan_sock *vs, struct vxlan_dev *vxlan)
1874 {
1875         __u32 vni = vxlan->default_dst.remote_vni;
1876
1877         vxlan->vn_sock = vs;
1878         hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));
1879 }
1880
1881 /* Setup stats when device is created */
1882 static int vxlan_init(struct net_device *dev)
1883 {
1884         struct vxlan_dev *vxlan = netdev_priv(dev);
1885         struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
1886         struct vxlan_sock *vs;
1887         int i;
1888
1889         dev->tstats = alloc_percpu(struct pcpu_sw_netstats);
1890         if (!dev->tstats)
1891                 return -ENOMEM;
1892
1893         for_each_possible_cpu(i) {
1894                 struct pcpu_sw_netstats *vxlan_stats;
1895                 vxlan_stats = per_cpu_ptr(dev->tstats, i);
1896                 u64_stats_init(&vxlan_stats->syncp);
1897         }
1898
1899
1900         spin_lock(&vn->sock_lock);
1901         vs = vxlan_find_sock(dev_net(dev), vxlan->dst_port);
1902         if (vs) {
1903                 /* If we have a socket with same port already, reuse it */
1904                 atomic_inc(&vs->refcnt);
1905                 vxlan_vs_add_dev(vs, vxlan);
1906         } else {
1907                 /* otherwise make new socket outside of RTNL */
1908                 dev_hold(dev);
1909                 queue_work(vxlan_wq, &vxlan->sock_work);
1910         }
1911         spin_unlock(&vn->sock_lock);
1912
1913         return 0;
1914 }
1915
1916 static void vxlan_fdb_delete_default(struct vxlan_dev *vxlan)
1917 {
1918         struct vxlan_fdb *f;
1919
1920         spin_lock_bh(&vxlan->hash_lock);
1921         f = __vxlan_find_mac(vxlan, all_zeros_mac);
1922         if (f)
1923                 vxlan_fdb_destroy(vxlan, f);
1924         spin_unlock_bh(&vxlan->hash_lock);
1925 }
1926
1927 static void vxlan_uninit(struct net_device *dev)
1928 {
1929         struct vxlan_dev *vxlan = netdev_priv(dev);
1930         struct vxlan_sock *vs = vxlan->vn_sock;
1931
1932         vxlan_fdb_delete_default(vxlan);
1933
1934         if (vs)
1935                 vxlan_sock_release(vs);
1936         free_percpu(dev->tstats);
1937 }
1938
1939 /* Start ageing timer and join group when device is brought up */
1940 static int vxlan_open(struct net_device *dev)
1941 {
1942         struct vxlan_dev *vxlan = netdev_priv(dev);
1943         struct vxlan_sock *vs = vxlan->vn_sock;
1944
1945         /* socket hasn't been created */
1946         if (!vs)
1947                 return -ENOTCONN;
1948
1949         if (vxlan_addr_multicast(&vxlan->default_dst.remote_ip)) {
1950                 vxlan_sock_hold(vs);
1951                 dev_hold(dev);
1952                 queue_work(vxlan_wq, &vxlan->igmp_join);
1953         }
1954
1955         if (vxlan->age_interval)
1956                 mod_timer(&vxlan->age_timer, jiffies + FDB_AGE_INTERVAL);
1957
1958         return 0;
1959 }
1960
1961 /* Purge the forwarding table */
1962 static void vxlan_flush(struct vxlan_dev *vxlan)
1963 {
1964         unsigned int h;
1965
1966         spin_lock_bh(&vxlan->hash_lock);
1967         for (h = 0; h < FDB_HASH_SIZE; ++h) {
1968                 struct hlist_node *p, *n;
1969                 hlist_for_each_safe(p, n, &vxlan->fdb_head[h]) {
1970                         struct vxlan_fdb *f
1971                                 = container_of(p, struct vxlan_fdb, hlist);
1972                         /* the all_zeros_mac entry is deleted at vxlan_uninit */
1973                         if (!is_zero_ether_addr(f->eth_addr))
1974                                 vxlan_fdb_destroy(vxlan, f);
1975                 }
1976         }
1977         spin_unlock_bh(&vxlan->hash_lock);
1978 }
1979
1980 /* Cleanup timer and forwarding table on shutdown */
1981 static int vxlan_stop(struct net_device *dev)
1982 {
1983         struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
1984         struct vxlan_dev *vxlan = netdev_priv(dev);
1985         struct vxlan_sock *vs = vxlan->vn_sock;
1986
1987         if (vs && vxlan_addr_multicast(&vxlan->default_dst.remote_ip) &&
1988             !vxlan_group_used(vn, vxlan)) {
1989                 vxlan_sock_hold(vs);
1990                 dev_hold(dev);
1991                 queue_work(vxlan_wq, &vxlan->igmp_leave);
1992         }
1993
1994         del_timer_sync(&vxlan->age_timer);
1995
1996         vxlan_flush(vxlan);
1997
1998         return 0;
1999 }
2000
2001 /* Stub, nothing needs to be done. */
2002 static void vxlan_set_multicast_list(struct net_device *dev)
2003 {
2004 }
2005
2006 static int vxlan_change_mtu(struct net_device *dev, int new_mtu)
2007 {
2008         struct vxlan_dev *vxlan = netdev_priv(dev);
2009         struct vxlan_rdst *dst = &vxlan->default_dst;
2010         struct net_device *lowerdev;
2011         int max_mtu;
2012
2013         lowerdev = __dev_get_by_index(dev_net(dev), dst->remote_ifindex);
2014         if (lowerdev == NULL)
2015                 return eth_change_mtu(dev, new_mtu);
2016
2017         if (dst->remote_ip.sa.sa_family == AF_INET6)
2018                 max_mtu = lowerdev->mtu - VXLAN6_HEADROOM;
2019         else
2020                 max_mtu = lowerdev->mtu - VXLAN_HEADROOM;
2021
2022         if (new_mtu < 68 || new_mtu > max_mtu)
2023                 return -EINVAL;
2024
2025         dev->mtu = new_mtu;
2026         return 0;
2027 }
2028
2029 static const struct net_device_ops vxlan_netdev_ops = {
2030         .ndo_init               = vxlan_init,
2031         .ndo_uninit             = vxlan_uninit,
2032         .ndo_open               = vxlan_open,
2033         .ndo_stop               = vxlan_stop,
2034         .ndo_start_xmit         = vxlan_xmit,
2035         .ndo_get_stats64        = ip_tunnel_get_stats64,
2036         .ndo_set_rx_mode        = vxlan_set_multicast_list,
2037         .ndo_change_mtu         = vxlan_change_mtu,
2038         .ndo_validate_addr      = eth_validate_addr,
2039         .ndo_set_mac_address    = eth_mac_addr,
2040         .ndo_fdb_add            = vxlan_fdb_add,
2041         .ndo_fdb_del            = vxlan_fdb_delete,
2042         .ndo_fdb_dump           = vxlan_fdb_dump,
2043 };
2044
2045 /* Info for udev, that this is a virtual tunnel endpoint */
2046 static struct device_type vxlan_type = {
2047         .name = "vxlan",
2048 };
2049
2050 /* Calls the ndo_add_vxlan_port of the caller in order to
2051  * supply the listening VXLAN udp ports. Callers are expected
2052  * to implement the ndo_add_vxlan_port.
2053  */
2054 void vxlan_get_rx_port(struct net_device *dev)
2055 {
2056         struct vxlan_sock *vs;
2057         struct net *net = dev_net(dev);
2058         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2059         sa_family_t sa_family;
2060         __be16 port;
2061         unsigned int i;
2062
2063         spin_lock(&vn->sock_lock);
2064         for (i = 0; i < PORT_HASH_SIZE; ++i) {
2065                 hlist_for_each_entry_rcu(vs, &vn->sock_list[i], hlist) {
2066                         port = inet_sk(vs->sock->sk)->inet_sport;
2067                         sa_family = vs->sock->sk->sk_family;
2068                         dev->netdev_ops->ndo_add_vxlan_port(dev, sa_family,
2069                                                             port);
2070                 }
2071         }
2072         spin_unlock(&vn->sock_lock);
2073 }
2074 EXPORT_SYMBOL_GPL(vxlan_get_rx_port);
2075
2076 /* Initialize the device structure. */
2077 static void vxlan_setup(struct net_device *dev)
2078 {
2079         struct vxlan_dev *vxlan = netdev_priv(dev);
2080         unsigned int h;
2081         int low, high;
2082
2083         eth_hw_addr_random(dev);
2084         ether_setup(dev);
2085         if (vxlan->default_dst.remote_ip.sa.sa_family == AF_INET6)
2086                 dev->hard_header_len = ETH_HLEN + VXLAN6_HEADROOM;
2087         else
2088                 dev->hard_header_len = ETH_HLEN + VXLAN_HEADROOM;
2089
2090         dev->netdev_ops = &vxlan_netdev_ops;
2091         dev->destructor = free_netdev;
2092         SET_NETDEV_DEVTYPE(dev, &vxlan_type);
2093
2094         dev->tx_queue_len = 0;
2095         dev->features   |= NETIF_F_LLTX;
2096         dev->features   |= NETIF_F_NETNS_LOCAL;
2097         dev->features   |= NETIF_F_SG | NETIF_F_HW_CSUM;
2098         dev->features   |= NETIF_F_RXCSUM;
2099         dev->features   |= NETIF_F_GSO_SOFTWARE;
2100
2101         dev->vlan_features = dev->features;
2102         dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
2103         dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
2104         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
2105         dev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
2106         dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
2107         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
2108
2109         INIT_LIST_HEAD(&vxlan->next);
2110         spin_lock_init(&vxlan->hash_lock);
2111         INIT_WORK(&vxlan->igmp_join, vxlan_igmp_join);
2112         INIT_WORK(&vxlan->igmp_leave, vxlan_igmp_leave);
2113         INIT_WORK(&vxlan->sock_work, vxlan_sock_work);
2114
2115         init_timer_deferrable(&vxlan->age_timer);
2116         vxlan->age_timer.function = vxlan_cleanup;
2117         vxlan->age_timer.data = (unsigned long) vxlan;
2118
2119         inet_get_local_port_range(dev_net(dev), &low, &high);
2120         vxlan->port_min = low;
2121         vxlan->port_max = high;
2122         vxlan->dst_port = htons(vxlan_port);
2123
2124         vxlan->dev = dev;
2125
2126         for (h = 0; h < FDB_HASH_SIZE; ++h)
2127                 INIT_HLIST_HEAD(&vxlan->fdb_head[h]);
2128 }
2129
2130 static const struct nla_policy vxlan_policy[IFLA_VXLAN_MAX + 1] = {
2131         [IFLA_VXLAN_ID]         = { .type = NLA_U32 },
2132         [IFLA_VXLAN_GROUP]      = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
2133         [IFLA_VXLAN_GROUP6]     = { .len = sizeof(struct in6_addr) },
2134         [IFLA_VXLAN_LINK]       = { .type = NLA_U32 },
2135         [IFLA_VXLAN_LOCAL]      = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
2136         [IFLA_VXLAN_LOCAL6]     = { .len = sizeof(struct in6_addr) },
2137         [IFLA_VXLAN_TOS]        = { .type = NLA_U8 },
2138         [IFLA_VXLAN_TTL]        = { .type = NLA_U8 },
2139         [IFLA_VXLAN_LEARNING]   = { .type = NLA_U8 },
2140         [IFLA_VXLAN_AGEING]     = { .type = NLA_U32 },
2141         [IFLA_VXLAN_LIMIT]      = { .type = NLA_U32 },
2142         [IFLA_VXLAN_PORT_RANGE] = { .len  = sizeof(struct ifla_vxlan_port_range) },
2143         [IFLA_VXLAN_PROXY]      = { .type = NLA_U8 },
2144         [IFLA_VXLAN_RSC]        = { .type = NLA_U8 },
2145         [IFLA_VXLAN_L2MISS]     = { .type = NLA_U8 },
2146         [IFLA_VXLAN_L3MISS]     = { .type = NLA_U8 },
2147         [IFLA_VXLAN_PORT]       = { .type = NLA_U16 },
2148 };
2149
2150 static int vxlan_validate(struct nlattr *tb[], struct nlattr *data[])
2151 {
2152         if (tb[IFLA_ADDRESS]) {
2153                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) {
2154                         pr_debug("invalid link address (not ethernet)\n");
2155                         return -EINVAL;
2156                 }
2157
2158                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) {
2159                         pr_debug("invalid all zero ethernet address\n");
2160                         return -EADDRNOTAVAIL;
2161                 }
2162         }
2163
2164         if (!data)
2165                 return -EINVAL;
2166
2167         if (data[IFLA_VXLAN_ID]) {
2168                 __u32 id = nla_get_u32(data[IFLA_VXLAN_ID]);
2169                 if (id >= VXLAN_VID_MASK)
2170                         return -ERANGE;
2171         }
2172
2173         if (data[IFLA_VXLAN_PORT_RANGE]) {
2174                 const struct ifla_vxlan_port_range *p
2175                         = nla_data(data[IFLA_VXLAN_PORT_RANGE]);
2176
2177                 if (ntohs(p->high) < ntohs(p->low)) {
2178                         pr_debug("port range %u .. %u not valid\n",
2179                                  ntohs(p->low), ntohs(p->high));
2180                         return -EINVAL;
2181                 }
2182         }
2183
2184         return 0;
2185 }
2186
2187 static void vxlan_get_drvinfo(struct net_device *netdev,
2188                               struct ethtool_drvinfo *drvinfo)
2189 {
2190         strlcpy(drvinfo->version, VXLAN_VERSION, sizeof(drvinfo->version));
2191         strlcpy(drvinfo->driver, "vxlan", sizeof(drvinfo->driver));
2192 }
2193
2194 static const struct ethtool_ops vxlan_ethtool_ops = {
2195         .get_drvinfo    = vxlan_get_drvinfo,
2196         .get_link       = ethtool_op_get_link,
2197 };
2198
2199 static void vxlan_del_work(struct work_struct *work)
2200 {
2201         struct vxlan_sock *vs = container_of(work, struct vxlan_sock, del_work);
2202
2203         sk_release_kernel(vs->sock->sk);
2204         kfree_rcu(vs, rcu);
2205 }
2206
2207 #if IS_ENABLED(CONFIG_IPV6)
2208 /* Create UDP socket for encapsulation receive. AF_INET6 socket
2209  * could be used for both IPv4 and IPv6 communications, but
2210  * users may set bindv6only=1.
2211  */
2212 static struct socket *create_v6_sock(struct net *net, __be16 port)
2213 {
2214         struct sock *sk;
2215         struct socket *sock;
2216         struct sockaddr_in6 vxlan_addr = {
2217                 .sin6_family = AF_INET6,
2218                 .sin6_port = port,
2219         };
2220         int rc, val = 1;
2221
2222         rc = sock_create_kern(AF_INET6, SOCK_DGRAM, IPPROTO_UDP, &sock);
2223         if (rc < 0) {
2224                 pr_debug("UDPv6 socket create failed\n");
2225                 return ERR_PTR(rc);
2226         }
2227
2228         /* Put in proper namespace */
2229         sk = sock->sk;
2230         sk_change_net(sk, net);
2231
2232         kernel_setsockopt(sock, SOL_IPV6, IPV6_V6ONLY,
2233                           (char *)&val, sizeof(val));
2234         rc = kernel_bind(sock, (struct sockaddr *)&vxlan_addr,
2235                          sizeof(struct sockaddr_in6));
2236         if (rc < 0) {
2237                 pr_debug("bind for UDPv6 socket %pI6:%u (%d)\n",
2238                          &vxlan_addr.sin6_addr, ntohs(vxlan_addr.sin6_port), rc);
2239                 sk_release_kernel(sk);
2240                 return ERR_PTR(rc);
2241         }
2242         /* At this point, IPv6 module should have been loaded in
2243          * sock_create_kern().
2244          */
2245         BUG_ON(!ipv6_stub);
2246
2247         /* Disable multicast loopback */
2248         inet_sk(sk)->mc_loop = 0;
2249         return sock;
2250 }
2251
2252 #else
2253
2254 static struct socket *create_v6_sock(struct net *net, __be16 port)
2255 {
2256                 return ERR_PTR(-EPFNOSUPPORT);
2257 }
2258 #endif
2259
2260 static struct socket *create_v4_sock(struct net *net, __be16 port)
2261 {
2262         struct sock *sk;
2263         struct socket *sock;
2264         struct sockaddr_in vxlan_addr = {
2265                 .sin_family = AF_INET,
2266                 .sin_addr.s_addr = htonl(INADDR_ANY),
2267                 .sin_port = port,
2268         };
2269         int rc;
2270
2271         /* Create UDP socket for encapsulation receive. */
2272         rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
2273         if (rc < 0) {
2274                 pr_debug("UDP socket create failed\n");
2275                 return ERR_PTR(rc);
2276         }
2277
2278         /* Put in proper namespace */
2279         sk = sock->sk;
2280         sk_change_net(sk, net);
2281
2282         rc = kernel_bind(sock, (struct sockaddr *) &vxlan_addr,
2283                          sizeof(vxlan_addr));
2284         if (rc < 0) {
2285                 pr_debug("bind for UDP socket %pI4:%u (%d)\n",
2286                          &vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);
2287                 sk_release_kernel(sk);
2288                 return ERR_PTR(rc);
2289         }
2290
2291         /* Disable multicast loopback */
2292         inet_sk(sk)->mc_loop = 0;
2293         return sock;
2294 }
2295
2296 /* Create new listen socket if needed */
2297 static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port,
2298                                               vxlan_rcv_t *rcv, void *data, bool ipv6)
2299 {
2300         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2301         struct vxlan_sock *vs;
2302         struct socket *sock;
2303         struct sock *sk;
2304         unsigned int h;
2305
2306         vs = kmalloc(sizeof(*vs), GFP_KERNEL);
2307         if (!vs)
2308                 return ERR_PTR(-ENOMEM);
2309
2310         for (h = 0; h < VNI_HASH_SIZE; ++h)
2311                 INIT_HLIST_HEAD(&vs->vni_list[h]);
2312
2313         INIT_WORK(&vs->del_work, vxlan_del_work);
2314
2315         if (ipv6)
2316                 sock = create_v6_sock(net, port);
2317         else
2318                 sock = create_v4_sock(net, port);
2319         if (IS_ERR(sock)) {
2320                 kfree(vs);
2321                 return ERR_CAST(sock);
2322         }
2323
2324         vs->sock = sock;
2325         sk = sock->sk;
2326         atomic_set(&vs->refcnt, 1);
2327         vs->rcv = rcv;
2328         vs->data = data;
2329         rcu_assign_sk_user_data(vs->sock->sk, vs);
2330
2331         spin_lock(&vn->sock_lock);
2332         hlist_add_head_rcu(&vs->hlist, vs_head(net, port));
2333         vxlan_notify_add_rx_port(sk);
2334         spin_unlock(&vn->sock_lock);
2335
2336         /* Mark socket as an encapsulation socket. */
2337         udp_sk(sk)->encap_type = 1;
2338         udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
2339 #if IS_ENABLED(CONFIG_IPV6)
2340         if (ipv6)
2341                 ipv6_stub->udpv6_encap_enable();
2342         else
2343 #endif
2344                 udp_encap_enable();
2345
2346         return vs;
2347 }
2348
2349 struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,
2350                                   vxlan_rcv_t *rcv, void *data,
2351                                   bool no_share, bool ipv6)
2352 {
2353         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2354         struct vxlan_sock *vs;
2355
2356         vs = vxlan_socket_create(net, port, rcv, data, ipv6);
2357         if (!IS_ERR(vs))
2358                 return vs;
2359
2360         if (no_share)   /* Return error if sharing is not allowed. */
2361                 return vs;
2362
2363         spin_lock(&vn->sock_lock);
2364         vs = vxlan_find_sock(net, port);
2365         if (vs) {
2366                 if (vs->rcv == rcv)
2367                         atomic_inc(&vs->refcnt);
2368                 else
2369                         vs = ERR_PTR(-EBUSY);
2370         }
2371         spin_unlock(&vn->sock_lock);
2372
2373         if (!vs)
2374                 vs = ERR_PTR(-EINVAL);
2375
2376         return vs;
2377 }
2378 EXPORT_SYMBOL_GPL(vxlan_sock_add);
2379
2380 /* Scheduled at device creation to bind to a socket */
2381 static void vxlan_sock_work(struct work_struct *work)
2382 {
2383         struct vxlan_dev *vxlan = container_of(work, struct vxlan_dev, sock_work);
2384         struct net *net = dev_net(vxlan->dev);
2385         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2386         __be16 port = vxlan->dst_port;
2387         struct vxlan_sock *nvs;
2388
2389         nvs = vxlan_sock_add(net, port, vxlan_rcv, NULL, false, vxlan->flags & VXLAN_F_IPV6);
2390         spin_lock(&vn->sock_lock);
2391         if (!IS_ERR(nvs))
2392                 vxlan_vs_add_dev(nvs, vxlan);
2393         spin_unlock(&vn->sock_lock);
2394
2395         dev_put(vxlan->dev);
2396 }
2397
2398 static int vxlan_newlink(struct net *net, struct net_device *dev,
2399                          struct nlattr *tb[], struct nlattr *data[])
2400 {
2401         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2402         struct vxlan_dev *vxlan = netdev_priv(dev);
2403         struct vxlan_rdst *dst = &vxlan->default_dst;
2404         __u32 vni;
2405         int err;
2406         bool use_ipv6 = false;
2407
2408         if (!data[IFLA_VXLAN_ID])
2409                 return -EINVAL;
2410
2411         vni = nla_get_u32(data[IFLA_VXLAN_ID]);
2412         dst->remote_vni = vni;
2413
2414         if (data[IFLA_VXLAN_GROUP]) {
2415                 dst->remote_ip.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_GROUP]);
2416                 dst->remote_ip.sa.sa_family = AF_INET;
2417         } else if (data[IFLA_VXLAN_GROUP6]) {
2418                 if (!IS_ENABLED(CONFIG_IPV6))
2419                         return -EPFNOSUPPORT;
2420
2421                 nla_memcpy(&dst->remote_ip.sin6.sin6_addr, data[IFLA_VXLAN_GROUP6],
2422                            sizeof(struct in6_addr));
2423                 dst->remote_ip.sa.sa_family = AF_INET6;
2424                 use_ipv6 = true;
2425         }
2426
2427         if (data[IFLA_VXLAN_LOCAL]) {
2428                 vxlan->saddr.sin.sin_addr.s_addr = nla_get_be32(data[IFLA_VXLAN_LOCAL]);
2429                 vxlan->saddr.sa.sa_family = AF_INET;
2430         } else if (data[IFLA_VXLAN_LOCAL6]) {
2431                 if (!IS_ENABLED(CONFIG_IPV6))
2432                         return -EPFNOSUPPORT;
2433
2434                 /* TODO: respect scope id */
2435                 nla_memcpy(&vxlan->saddr.sin6.sin6_addr, data[IFLA_VXLAN_LOCAL6],
2436                            sizeof(struct in6_addr));
2437                 vxlan->saddr.sa.sa_family = AF_INET6;
2438                 use_ipv6 = true;
2439         }
2440
2441         if (data[IFLA_VXLAN_LINK] &&
2442             (dst->remote_ifindex = nla_get_u32(data[IFLA_VXLAN_LINK]))) {
2443                 struct net_device *lowerdev
2444                          = __dev_get_by_index(net, dst->remote_ifindex);
2445
2446                 if (!lowerdev) {
2447                         pr_info("ifindex %d does not exist\n", dst->remote_ifindex);
2448                         return -ENODEV;
2449                 }
2450
2451 #if IS_ENABLED(CONFIG_IPV6)
2452                 if (use_ipv6) {
2453                         struct inet6_dev *idev = __in6_dev_get(lowerdev);
2454                         if (idev && idev->cnf.disable_ipv6) {
2455                                 pr_info("IPv6 is disabled via sysctl\n");
2456                                 return -EPERM;
2457                         }
2458                         vxlan->flags |= VXLAN_F_IPV6;
2459                 }
2460 #endif
2461
2462                 if (!tb[IFLA_MTU])
2463                         dev->mtu = lowerdev->mtu - (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
2464
2465                 /* update header length based on lower device */
2466                 dev->hard_header_len = lowerdev->hard_header_len +
2467                                        (use_ipv6 ? VXLAN6_HEADROOM : VXLAN_HEADROOM);
2468         } else if (use_ipv6)
2469                 vxlan->flags |= VXLAN_F_IPV6;
2470
2471         if (data[IFLA_VXLAN_TOS])
2472                 vxlan->tos  = nla_get_u8(data[IFLA_VXLAN_TOS]);
2473
2474         if (data[IFLA_VXLAN_TTL])
2475                 vxlan->ttl = nla_get_u8(data[IFLA_VXLAN_TTL]);
2476
2477         if (!data[IFLA_VXLAN_LEARNING] || nla_get_u8(data[IFLA_VXLAN_LEARNING]))
2478                 vxlan->flags |= VXLAN_F_LEARN;
2479
2480         if (data[IFLA_VXLAN_AGEING])
2481                 vxlan->age_interval = nla_get_u32(data[IFLA_VXLAN_AGEING]);
2482         else
2483                 vxlan->age_interval = FDB_AGE_DEFAULT;
2484
2485         if (data[IFLA_VXLAN_PROXY] && nla_get_u8(data[IFLA_VXLAN_PROXY]))
2486                 vxlan->flags |= VXLAN_F_PROXY;
2487
2488         if (data[IFLA_VXLAN_RSC] && nla_get_u8(data[IFLA_VXLAN_RSC]))
2489                 vxlan->flags |= VXLAN_F_RSC;
2490
2491         if (data[IFLA_VXLAN_L2MISS] && nla_get_u8(data[IFLA_VXLAN_L2MISS]))
2492                 vxlan->flags |= VXLAN_F_L2MISS;
2493
2494         if (data[IFLA_VXLAN_L3MISS] && nla_get_u8(data[IFLA_VXLAN_L3MISS]))
2495                 vxlan->flags |= VXLAN_F_L3MISS;
2496
2497         if (data[IFLA_VXLAN_LIMIT])
2498                 vxlan->addrmax = nla_get_u32(data[IFLA_VXLAN_LIMIT]);
2499
2500         if (data[IFLA_VXLAN_PORT_RANGE]) {
2501                 const struct ifla_vxlan_port_range *p
2502                         = nla_data(data[IFLA_VXLAN_PORT_RANGE]);
2503                 vxlan->port_min = ntohs(p->low);
2504                 vxlan->port_max = ntohs(p->high);
2505         }
2506
2507         if (data[IFLA_VXLAN_PORT])
2508                 vxlan->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);
2509
2510         if (vxlan_find_vni(net, vni, vxlan->dst_port)) {
2511                 pr_info("duplicate VNI %u\n", vni);
2512                 return -EEXIST;
2513         }
2514
2515         SET_ETHTOOL_OPS(dev, &vxlan_ethtool_ops);
2516
2517         /* create an fdb entry for a valid default destination */
2518         if (!vxlan_addr_any(&vxlan->default_dst.remote_ip)) {
2519                 err = vxlan_fdb_create(vxlan, all_zeros_mac,
2520                                        &vxlan->default_dst.remote_ip,
2521                                        NUD_REACHABLE|NUD_PERMANENT,
2522                                        NLM_F_EXCL|NLM_F_CREATE,
2523                                        vxlan->dst_port,
2524                                        vxlan->default_dst.remote_vni,
2525                                        vxlan->default_dst.remote_ifindex,
2526                                        NTF_SELF);
2527                 if (err)
2528                         return err;
2529         }
2530
2531         err = register_netdevice(dev);
2532         if (err) {
2533                 vxlan_fdb_delete_default(vxlan);
2534                 return err;
2535         }
2536
2537         list_add(&vxlan->next, &vn->vxlan_list);
2538
2539         return 0;
2540 }
2541
2542 static void vxlan_dellink(struct net_device *dev, struct list_head *head)
2543 {
2544         struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
2545         struct vxlan_dev *vxlan = netdev_priv(dev);
2546
2547         spin_lock(&vn->sock_lock);
2548         if (!hlist_unhashed(&vxlan->hlist))
2549                 hlist_del_rcu(&vxlan->hlist);
2550         spin_unlock(&vn->sock_lock);
2551
2552         list_del(&vxlan->next);
2553         unregister_netdevice_queue(dev, head);
2554 }
2555
2556 static size_t vxlan_get_size(const struct net_device *dev)
2557 {
2558
2559         return nla_total_size(sizeof(__u32)) +  /* IFLA_VXLAN_ID */
2560                 nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_GROUP{6} */
2561                 nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_LINK */
2562                 nla_total_size(sizeof(struct in6_addr)) + /* IFLA_VXLAN_LOCAL{6} */
2563                 nla_total_size(sizeof(__u8)) +  /* IFLA_VXLAN_TTL */
2564                 nla_total_size(sizeof(__u8)) +  /* IFLA_VXLAN_TOS */
2565                 nla_total_size(sizeof(__u8)) +  /* IFLA_VXLAN_LEARNING */
2566                 nla_total_size(sizeof(__u8)) +  /* IFLA_VXLAN_PROXY */
2567                 nla_total_size(sizeof(__u8)) +  /* IFLA_VXLAN_RSC */
2568                 nla_total_size(sizeof(__u8)) +  /* IFLA_VXLAN_L2MISS */
2569                 nla_total_size(sizeof(__u8)) +  /* IFLA_VXLAN_L3MISS */
2570                 nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_AGEING */
2571                 nla_total_size(sizeof(__u32)) + /* IFLA_VXLAN_LIMIT */
2572                 nla_total_size(sizeof(struct ifla_vxlan_port_range)) +
2573                 nla_total_size(sizeof(__be16))+ /* IFLA_VXLAN_PORT */
2574                 0;
2575 }
2576
2577 static int vxlan_fill_info(struct sk_buff *skb, const struct net_device *dev)
2578 {
2579         const struct vxlan_dev *vxlan = netdev_priv(dev);
2580         const struct vxlan_rdst *dst = &vxlan->default_dst;
2581         struct ifla_vxlan_port_range ports = {
2582                 .low =  htons(vxlan->port_min),
2583                 .high = htons(vxlan->port_max),
2584         };
2585
2586         if (nla_put_u32(skb, IFLA_VXLAN_ID, dst->remote_vni))
2587                 goto nla_put_failure;
2588
2589         if (!vxlan_addr_any(&dst->remote_ip)) {
2590                 if (dst->remote_ip.sa.sa_family == AF_INET) {
2591                         if (nla_put_be32(skb, IFLA_VXLAN_GROUP,
2592                                          dst->remote_ip.sin.sin_addr.s_addr))
2593                                 goto nla_put_failure;
2594 #if IS_ENABLED(CONFIG_IPV6)
2595                 } else {
2596                         if (nla_put(skb, IFLA_VXLAN_GROUP6, sizeof(struct in6_addr),
2597                                     &dst->remote_ip.sin6.sin6_addr))
2598                                 goto nla_put_failure;
2599 #endif
2600                 }
2601         }
2602
2603         if (dst->remote_ifindex && nla_put_u32(skb, IFLA_VXLAN_LINK, dst->remote_ifindex))
2604                 goto nla_put_failure;
2605
2606         if (!vxlan_addr_any(&vxlan->saddr)) {
2607                 if (vxlan->saddr.sa.sa_family == AF_INET) {
2608                         if (nla_put_be32(skb, IFLA_VXLAN_LOCAL,
2609                                          vxlan->saddr.sin.sin_addr.s_addr))
2610                                 goto nla_put_failure;
2611 #if IS_ENABLED(CONFIG_IPV6)
2612                 } else {
2613                         if (nla_put(skb, IFLA_VXLAN_LOCAL6, sizeof(struct in6_addr),
2614                                     &vxlan->saddr.sin6.sin6_addr))
2615                                 goto nla_put_failure;
2616 #endif
2617                 }
2618         }
2619
2620         if (nla_put_u8(skb, IFLA_VXLAN_TTL, vxlan->ttl) ||
2621             nla_put_u8(skb, IFLA_VXLAN_TOS, vxlan->tos) ||
2622             nla_put_u8(skb, IFLA_VXLAN_LEARNING,
2623                         !!(vxlan->flags & VXLAN_F_LEARN)) ||
2624             nla_put_u8(skb, IFLA_VXLAN_PROXY,
2625                         !!(vxlan->flags & VXLAN_F_PROXY)) ||
2626             nla_put_u8(skb, IFLA_VXLAN_RSC, !!(vxlan->flags & VXLAN_F_RSC)) ||
2627             nla_put_u8(skb, IFLA_VXLAN_L2MISS,
2628                         !!(vxlan->flags & VXLAN_F_L2MISS)) ||
2629             nla_put_u8(skb, IFLA_VXLAN_L3MISS,
2630                         !!(vxlan->flags & VXLAN_F_L3MISS)) ||
2631             nla_put_u32(skb, IFLA_VXLAN_AGEING, vxlan->age_interval) ||
2632             nla_put_u32(skb, IFLA_VXLAN_LIMIT, vxlan->addrmax) ||
2633             nla_put_be16(skb, IFLA_VXLAN_PORT, vxlan->dst_port))
2634                 goto nla_put_failure;
2635
2636         if (nla_put(skb, IFLA_VXLAN_PORT_RANGE, sizeof(ports), &ports))
2637                 goto nla_put_failure;
2638
2639         return 0;
2640
2641 nla_put_failure:
2642         return -EMSGSIZE;
2643 }
2644
2645 static struct rtnl_link_ops vxlan_link_ops __read_mostly = {
2646         .kind           = "vxlan",
2647         .maxtype        = IFLA_VXLAN_MAX,
2648         .policy         = vxlan_policy,
2649         .priv_size      = sizeof(struct vxlan_dev),
2650         .setup          = vxlan_setup,
2651         .validate       = vxlan_validate,
2652         .newlink        = vxlan_newlink,
2653         .dellink        = vxlan_dellink,
2654         .get_size       = vxlan_get_size,
2655         .fill_info      = vxlan_fill_info,
2656 };
2657
2658 static void vxlan_handle_lowerdev_unregister(struct vxlan_net *vn,
2659                                              struct net_device *dev)
2660 {
2661         struct vxlan_dev *vxlan, *next;
2662         LIST_HEAD(list_kill);
2663
2664         list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next) {
2665                 struct vxlan_rdst *dst = &vxlan->default_dst;
2666
2667                 /* In case we created vxlan device with carrier
2668                  * and we loose the carrier due to module unload
2669                  * we also need to remove vxlan device. In other
2670                  * cases, it's not necessary and remote_ifindex
2671                  * is 0 here, so no matches.
2672                  */
2673                 if (dst->remote_ifindex == dev->ifindex)
2674                         vxlan_dellink(vxlan->dev, &list_kill);
2675         }
2676
2677         unregister_netdevice_many(&list_kill);
2678 }
2679
2680 static int vxlan_lowerdev_event(struct notifier_block *unused,
2681                                 unsigned long event, void *ptr)
2682 {
2683         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2684         struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
2685
2686         if (event == NETDEV_UNREGISTER)
2687                 vxlan_handle_lowerdev_unregister(vn, dev);
2688
2689         return NOTIFY_DONE;
2690 }
2691
2692 static struct notifier_block vxlan_notifier_block __read_mostly = {
2693         .notifier_call = vxlan_lowerdev_event,
2694 };
2695
2696 static __net_init int vxlan_init_net(struct net *net)
2697 {
2698         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2699         unsigned int h;
2700
2701         INIT_LIST_HEAD(&vn->vxlan_list);
2702         spin_lock_init(&vn->sock_lock);
2703
2704         for (h = 0; h < PORT_HASH_SIZE; ++h)
2705                 INIT_HLIST_HEAD(&vn->sock_list[h]);
2706
2707         return 0;
2708 }
2709
2710 static __net_exit void vxlan_exit_net(struct net *net)
2711 {
2712         struct vxlan_net *vn = net_generic(net, vxlan_net_id);
2713         struct vxlan_dev *vxlan;
2714         LIST_HEAD(list);
2715
2716         rtnl_lock();
2717         list_for_each_entry(vxlan, &vn->vxlan_list, next)
2718                 unregister_netdevice_queue(vxlan->dev, &list);
2719         unregister_netdevice_many(&list);
2720         rtnl_unlock();
2721 }
2722
2723 static struct pernet_operations vxlan_net_ops = {
2724         .init = vxlan_init_net,
2725         .exit = vxlan_exit_net,
2726         .id   = &vxlan_net_id,
2727         .size = sizeof(struct vxlan_net),
2728 };
2729
2730 static int __init vxlan_init_module(void)
2731 {
2732         int rc;
2733
2734         vxlan_wq = alloc_workqueue("vxlan", 0, 0);
2735         if (!vxlan_wq)
2736                 return -ENOMEM;
2737
2738         get_random_bytes(&vxlan_salt, sizeof(vxlan_salt));
2739
2740         rc = register_pernet_device(&vxlan_net_ops);
2741         if (rc)
2742                 goto out1;
2743
2744         rc = register_netdevice_notifier(&vxlan_notifier_block);
2745         if (rc)
2746                 goto out2;
2747
2748         rc = rtnl_link_register(&vxlan_link_ops);
2749         if (rc)
2750                 goto out3;
2751
2752         return 0;
2753 out3:
2754         unregister_netdevice_notifier(&vxlan_notifier_block);
2755 out2:
2756         unregister_pernet_device(&vxlan_net_ops);
2757 out1:
2758         destroy_workqueue(vxlan_wq);
2759         return rc;
2760 }
2761 late_initcall(vxlan_init_module);
2762
2763 static void __exit vxlan_cleanup_module(void)
2764 {
2765         rtnl_link_unregister(&vxlan_link_ops);
2766         unregister_netdevice_notifier(&vxlan_notifier_block);
2767         destroy_workqueue(vxlan_wq);
2768         unregister_pernet_device(&vxlan_net_ops);
2769         rcu_barrier();
2770 }
2771 module_exit(vxlan_cleanup_module);
2772
2773 MODULE_LICENSE("GPL");
2774 MODULE_VERSION(VXLAN_VERSION);
2775 MODULE_AUTHOR("Stephen Hemminger <stephen@networkplumber.org>");
2776 MODULE_ALIAS_RTNL_LINK("vxlan");