datapath/linux/compat/lisp.c

   1 /*
   2  * Copyright (c) 2015 Nicira, Inc.
   3  * Copyright (c) 2013 Cisco Systems, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of version 2 of the GNU General Public
   7  * License as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12  * General Public License for more details.
  13  *
  14  */
  15
  16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  17
  18 #include <linux/version.h>
  19
  20 #include <linux/etherdevice.h>
  21 #include <linux/in.h>
  22 #include <linux/ip.h>
  23 #include <linux/net.h>
  24 #include <linux/module.h>
  25 #include <linux/rculist.h>
  26 #include <linux/udp.h>
  27
  28 #include <net/icmp.h>
  29 #include <net/ip.h>
  30 #include <net/lisp.h>
  31 #include <net/net_namespace.h>
  32 #include <net/netns/generic.h>
  33 #include <net/route.h>
  34 #include <net/udp.h>
  35 #include <net/udp_tunnel.h>
  36 #include <net/xfrm.h>
  37
  38 #include "datapath.h"
  39 #include "gso.h"
  40 #include "vport.h"
  41 #include "gso.h"
  42 #include "vport-netdev.h"
  43
  44 #define LISP_UDP_PORT           4341
  45 #define LISP_NETDEV_VER         "0.1"
  46 static int lisp_net_id;
  47
  48 /* Pseudo network device */
  49 struct lisp_dev {
  50         struct net         *net;        /* netns for packet i/o */
  51         struct net_device  *dev;        /* netdev for lisp tunnel */
  52         struct socket __rcu  *sock;
  53         __be16             dst_port;
  54         struct list_head   next;
  55 };
  56
  57 /* per-network namespace private data for this module */
  58 struct lisp_net {
  59         struct list_head lisp_list;
  60 };
  61
  62 /*
  63  *  LISP encapsulation header:
  64  *
  65  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  66  *  |N|L|E|V|I|flags|            Nonce/Map-Version                  |
  67  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  68  *  |                 Instance ID/Locator Status Bits               |
  69  *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  70  *
  71  */
  72
  73 /**
  74  * struct lisphdr - LISP header
  75  * @nonce_present: Flag indicating the presence of a 24 bit nonce value.
  76  * @locator_status_bits_present: Flag indicating the presence of Locator Status
  77  *                               Bits (LSB).
  78  * @solicit_echo_nonce: Flag indicating the use of the echo noncing mechanism.
  79  * @map_version_present: Flag indicating the use of mapping versioning.
  80  * @instance_id_present: Flag indicating the presence of a 24 bit Instance ID.
  81  * @reserved_flags: 3 bits reserved for future flags.
  82  * @nonce: 24 bit nonce value.
  83  * @map_version: 24 bit mapping version.
  84  * @locator_status_bits: Locator Status Bits: 32 bits when instance_id_present
  85  *                       is not set, 8 bits when it is.
  86  * @instance_id: 24 bit Instance ID
  87  */
  88 struct lisphdr {
  89 #ifdef __LITTLE_ENDIAN_BITFIELD
  90         __u8 reserved_flags:3;
  91         __u8 instance_id_present:1;
  92         __u8 map_version_present:1;
  93         __u8 solicit_echo_nonce:1;
  94         __u8 locator_status_bits_present:1;
  95         __u8 nonce_present:1;
  96 #else
  97         __u8 nonce_present:1;
  98         __u8 locator_status_bits_present:1;
  99         __u8 solicit_echo_nonce:1;
 100         __u8 map_version_present:1;
 101         __u8 instance_id_present:1;
 102         __u8 reserved_flags:3;
 103 #endif
 104         union {
 105                 __u8 nonce[3];
 106                 __u8 map_version[3];
 107         } u1;
 108         union {
 109                 __be32 locator_status_bits;
 110                 struct {
 111                         __u8 instance_id[3];
 112                         __u8 locator_status_bits;
 113                 } word2;
 114         } u2;
 115 };
 116
 117 #define LISP_HLEN (sizeof(struct udphdr) + sizeof(struct lisphdr))
 118 #define LISP_MAX_MTU (IP_MAX_MTU - LISP_HLEN - sizeof(struct iphdr))
 119
 120 static inline struct lisphdr *lisp_hdr(const struct sk_buff *skb)
 121 {
 122         return (struct lisphdr *)(udp_hdr(skb) + 1);
 123 }
 124
 125 /* Convert 64 bit tunnel ID to 24 bit Instance ID. */
 126 static void tunnel_id_to_instance_id(__be64 tun_id, __u8 *iid)
 127 {
 128
 129 #ifdef __BIG_ENDIAN
 130         iid[0] = (__force __u8)(tun_id >> 16);
 131         iid[1] = (__force __u8)(tun_id >> 8);
 132         iid[2] = (__force __u8)tun_id;
 133 #else
 134         iid[0] = (__force __u8)((__force u64)tun_id >> 40);
 135         iid[1] = (__force __u8)((__force u64)tun_id >> 48);
 136         iid[2] = (__force __u8)((__force u64)tun_id >> 56);
 137 #endif
 138 }
 139
 140 /* Convert 24 bit Instance ID to 64 bit tunnel ID. */
 141 static __be64 instance_id_to_tunnel_id(__u8 *iid)
 142 {
 143 #ifdef __BIG_ENDIAN
 144         return (iid[0] << 16) | (iid[1] << 8) | iid[2];
 145 #else
 146         return (__force __be64)(((__force u64)iid[0] << 40) |
 147                         ((__force u64)iid[1] << 48) |
 148                         ((__force u64)iid[2] << 56));
 149 #endif
 150 }
 151
 152 /* Compute source UDP port for outgoing packet.
 153  * Currently we use the flow hash.
 154  */
 155 static u16 get_src_port(struct net *net, struct sk_buff *skb)
 156 {
 157         u32 hash = skb_get_hash(skb);
 158         unsigned int range;
 159         int high;
 160         int low;
 161
 162         if (!hash) {
 163                 if (skb->protocol == htons(ETH_P_IP)) {
 164                         struct iphdr *iph;
 165                         int size = (sizeof(iph->saddr) * 2) / sizeof(u32);
 166
 167                         iph = (struct iphdr *) skb_network_header(skb);
 168                         hash = jhash2((const u32 *)&iph->saddr, size, 0);
 169                 } else if (skb->protocol == htons(ETH_P_IPV6)) {
 170                         struct ipv6hdr *ipv6hdr;
 171
 172                         ipv6hdr = (struct ipv6hdr *) skb_network_header(skb);
 173                         hash = jhash2((const u32 *)&ipv6hdr->saddr,
 174                                         (sizeof(struct in6_addr) * 2) / sizeof(u32), 0);
 175                 } else {
 176                         pr_warn_once("LISP inner protocol is not IP when "
 177                                         "calculating hash.\n");
 178                 }
 179         }
 180
 181         inet_get_local_port_range(net, &low, &high);
 182         range = (high - low) + 1;
 183         return (((u64) hash * range) >> 32) + low;
 184 }
 185
 186 static void lisp_build_header(struct sk_buff *skb,
 187                               const struct ip_tunnel_key *tun_key)
 188 {
 189         struct lisphdr *lisph;
 190
 191         lisph = (struct lisphdr *)__skb_push(skb, sizeof(struct lisphdr));
 192         lisph->nonce_present = 0;       /* We don't support echo nonce algorithm */
 193         lisph->locator_status_bits_present = 1; /* Set LSB */
 194         lisph->solicit_echo_nonce = 0;  /* No echo noncing */
 195         lisph->map_version_present = 0; /* No mapping versioning, nonce instead */
 196         lisph->instance_id_present = 1; /* Store the tun_id as Instance ID  */
 197         lisph->reserved_flags = 0;      /* Reserved flags, set to 0  */
 198
 199         lisph->u1.nonce[0] = 0;
 200         lisph->u1.nonce[1] = 0;
 201         lisph->u1.nonce[2] = 0;
 202
 203         tunnel_id_to_instance_id(tun_key->tun_id, &lisph->u2.word2.instance_id[0]);
 204         lisph->u2.word2.locator_status_bits = 1;
 205 }
 206
 207 /* Called with rcu_read_lock and BH disabled. */
 208 static int lisp_rcv(struct sock *sk, struct sk_buff *skb)
 209 {
 210         struct lisp_dev *lisp_dev;
 211         struct net_device *dev;
 212         struct lisphdr *lisph;
 213         struct iphdr *inner_iph;
 214         struct metadata_dst *tun_dst;
 215 #ifndef USE_UPSTREAM_TUNNEL
 216         struct metadata_dst temp;
 217 #endif
 218         __be64 key;
 219         struct ethhdr *ethh;
 220         __be16 protocol;
 221
 222         dev = rcu_dereference_sk_user_data(sk);
 223         if (unlikely(!dev))
 224                 goto error;
 225
 226         lisp_dev = netdev_priv(dev);
 227         if (iptunnel_pull_header(skb, LISP_HLEN, 0,
 228                                  !net_eq(lisp_dev->net, dev_net(lisp_dev->dev))))
 229                 goto error;
 230
 231         lisph = lisp_hdr(skb);
 232
 233         if (lisph->instance_id_present != 1)
 234                 key = 0;
 235         else
 236                 key = instance_id_to_tunnel_id(&lisph->u2.word2.instance_id[0]);
 237
 238         /* Save outer tunnel values */
 239 #ifndef USE_UPSTREAM_TUNNEL
 240         tun_dst = &temp;
 241         ovs_udp_tun_rx_dst(tun_dst, skb, AF_INET, TUNNEL_KEY, key, 0);
 242 #else
 243         tun_dst = udp_tun_rx_dst(skb, AF_INET, TUNNEL_KEY, key, 0);
 244 #endif
 245         /* Drop non-IP inner packets */
 246         inner_iph = (struct iphdr *)(lisph + 1);
 247         switch (inner_iph->version) {
 248         case 4:
 249                 protocol = htons(ETH_P_IP);
 250                 break;
 251         case 6:
 252                 protocol = htons(ETH_P_IPV6);
 253                 break;
 254         default:
 255                 goto error;
 256         }
 257         skb->protocol = protocol;
 258
 259         /* Add Ethernet header */
 260         ethh = (struct ethhdr *)skb_push(skb, ETH_HLEN);
 261         memset(ethh, 0, ETH_HLEN);
 262         ethh->h_dest[0] = 0x02;
 263         ethh->h_source[0] = 0x02;
 264         ethh->h_proto = protocol;
 265
 266         ovs_ip_tunnel_rcv(dev, skb, tun_dst);
 267         goto out;
 268
 269 error:
 270         kfree_skb(skb);
 271 out:
 272         return 0;
 273 }
 274
 275 static struct rtable *lisp_get_rt(struct sk_buff *skb,
 276                                  struct net_device *dev,
 277                                  struct flowi4 *fl,
 278                                  const struct ip_tunnel_key *key)
 279 {
 280         struct net *net = dev_net(dev);
 281
 282         /* Route lookup */
 283         memset(fl, 0, sizeof(*fl));
 284         fl->daddr = key->u.ipv4.dst;
 285         fl->saddr = key->u.ipv4.src;
 286         fl->flowi4_tos = RT_TOS(key->tos);
 287         fl->flowi4_mark = skb->mark;
 288         fl->flowi4_proto = IPPROTO_UDP;
 289
 290         return ip_route_output_key(net, fl);
 291 }
 292
 293 /* this is to handle the return type change in handle-offload
 294  * functions.
 295  */
 296 #if !defined(HAVE_UDP_TUNNEL_HANDLE_OFFLOAD_RET_SKB) || !defined(USE_UPSTREAM_TUNNEL)
 297 static struct sk_buff *
 298 __udp_tunnel_handle_offloads(struct sk_buff *skb, bool udp_csum)
 299 {
 300         int err;
 301
 302         err = udp_tunnel_handle_offloads(skb, udp_csum);
 303         if (err) {
 304                 kfree_skb(skb);
 305                 return NULL;
 306         }
 307         return skb;
 308 }
 309 #else
 310 #define __udp_tunnel_handle_offloads udp_tunnel_handle_offloads
 311 #endif
 312
 313 netdev_tx_t rpl_lisp_xmit(struct sk_buff *skb)
 314 {
 315         struct net_device *dev = skb->dev;
 316         struct lisp_dev *lisp_dev = netdev_priv(dev);
 317         struct net *net = lisp_dev->net;
 318         int network_offset = skb_network_offset(skb);
 319         struct ip_tunnel_info *info;
 320         struct ip_tunnel_key *tun_key;
 321         __be16 src_port, dst_port;
 322         struct rtable *rt;
 323         int min_headroom;
 324         struct socket *sock;
 325         struct flowi4 fl;
 326         __be16 df;
 327         int err;
 328
 329         info = skb_tunnel_info(skb);
 330         if (unlikely(!info)) {
 331                 err = -EINVAL;
 332                 goto error;
 333         }
 334
 335         sock = rcu_dereference(lisp_dev->sock);
 336         if (!sock) {
 337                 err = -EIO;
 338                 goto error;
 339         }
 340
 341         if (skb->protocol != htons(ETH_P_IP) &&
 342                         skb->protocol != htons(ETH_P_IPV6)) {
 343                 err = 0;
 344                 goto error;
 345         }
 346
 347         tun_key = &info->key;
 348
 349         rt = lisp_get_rt(skb, dev, &fl, tun_key);
 350         if (IS_ERR(rt)) {
 351                 err = PTR_ERR(rt);
 352                 goto error;
 353         }
 354
 355         min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
 356                 + sizeof(struct iphdr) + LISP_HLEN;
 357
 358         if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) {
 359                 int head_delta = SKB_DATA_ALIGN(min_headroom -
 360                                 skb_headroom(skb) +
 361                                 16);
 362
 363                 err = pskb_expand_head(skb, max_t(int, head_delta, 0),
 364                                 0, GFP_ATOMIC);
 365                 if (unlikely(err))
 366                         goto err_free_rt;
 367         }
 368
 369         /* Reset l2 headers. */
 370         skb_pull(skb, network_offset);
 371         skb_reset_mac_header(skb);
 372         skb->vlan_tci = 0;
 373
 374         if (skb_is_gso(skb) && skb_is_encapsulated(skb))
 375                 goto err_free_rt;
 376
 377         skb = __udp_tunnel_handle_offloads(skb, false);
 378         if (!skb)
 379                 return NETDEV_TX_OK;
 380
 381         src_port = htons(get_src_port(net, skb));
 382         dst_port = lisp_dev->dst_port;
 383
 384         lisp_build_header(skb, tun_key);
 385
 386         skb->ignore_df = 1;
 387
 388         ovs_skb_set_inner_protocol(skb, skb->protocol);
 389
 390         df = tun_key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
 391         udp_tunnel_xmit_skb(rt, sock->sk, skb,
 392                             fl.saddr, tun_key->u.ipv4.dst,
 393                             tun_key->tos, tun_key->ttl,
 394                             df, src_port, dst_port, false, true);
 395
 396         return NETDEV_TX_OK;
 397
 398 err_free_rt:
 399         ip_rt_put(rt);
 400 error:
 401         kfree_skb(skb);
 402         return NETDEV_TX_OK;
 403 }
 404 EXPORT_SYMBOL(rpl_lisp_xmit);
 405
 406 /* Setup stats when device is created */
 407 static int lisp_init(struct net_device *dev)
 408 {
 409         dev->tstats = (typeof(dev->tstats)) netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
 410         if (!dev->tstats)
 411                 return -ENOMEM;
 412
 413         return 0;
 414 }
 415
 416 static void lisp_uninit(struct net_device *dev)
 417 {
 418         free_percpu(dev->tstats);
 419 }
 420
 421 static struct socket *create_sock(struct net *net, bool ipv6,
 422                                        __be16 port)
 423 {
 424         struct socket *sock;
 425         struct udp_port_cfg udp_conf;
 426         int err;
 427
 428         memset(&udp_conf, 0, sizeof(udp_conf));
 429
 430         if (ipv6) {
 431                 udp_conf.family = AF_INET6;
 432         } else {
 433                 udp_conf.family = AF_INET;
 434                 udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
 435         }
 436
 437         udp_conf.local_udp_port = port;
 438
 439         /* Open UDP socket */
 440         err = udp_sock_create(net, &udp_conf, &sock);
 441         if (err < 0)
 442                 return ERR_PTR(err);
 443
 444         return sock;
 445 }
 446
 447 static int lisp_open(struct net_device *dev)
 448 {
 449         struct lisp_dev *lisp = netdev_priv(dev);
 450         struct udp_tunnel_sock_cfg tunnel_cfg;
 451         struct net *net = lisp->net;
 452         struct socket *sock;
 453
 454         sock = create_sock(net, false, lisp->dst_port);
 455         if (IS_ERR(sock))
 456                 return PTR_ERR(sock);
 457
 458         rcu_assign_pointer(lisp->sock, sock);
 459         /* Mark socket as an encapsulation socket */
 460         tunnel_cfg.sk_user_data = dev;
 461         tunnel_cfg.encap_type = 1;
 462         tunnel_cfg.encap_rcv = lisp_rcv;
 463         tunnel_cfg.encap_destroy = NULL;
 464         setup_udp_tunnel_sock(net, sock, &tunnel_cfg);
 465         return 0;
 466 }
 467
 468 static int lisp_stop(struct net_device *dev)
 469 {
 470         struct lisp_dev *lisp = netdev_priv(dev);
 471         struct socket *socket;
 472
 473         socket = rtnl_dereference(lisp->sock);
 474         if (!socket)
 475                 return 0;
 476
 477         rcu_assign_pointer(lisp->sock, NULL);
 478
 479         synchronize_net();
 480         udp_tunnel_sock_release(socket);
 481         return 0;
 482 }
 483
 484 static netdev_tx_t lisp_dev_xmit(struct sk_buff *skb, struct net_device *dev)
 485 {
 486 #ifdef USE_UPSTREAM_TUNNEL
 487         return rpl_lisp_xmit(skb);
 488 #else
 489         /* Drop All packets coming from networking stack. OVS-CB is
 490          * not initialized for these packets.
 491          */
 492
 493         dev_kfree_skb(skb);
 494         dev->stats.tx_dropped++;
 495         return NETDEV_TX_OK;
 496 #endif
 497 }
 498
 499 static int lisp_change_mtu(struct net_device *dev, int new_mtu)
 500 {
 501         if (new_mtu < 68 || new_mtu > LISP_MAX_MTU)
 502                 return -EINVAL;
 503
 504         dev->mtu = new_mtu;
 505         return 0;
 506 }
 507
 508 static int egress_ipv4_tun_info(struct net_device *dev, struct sk_buff *skb,
 509                                 struct ip_tunnel_info *info,
 510                                 __be16 sport, __be16 dport)
 511 {
 512         struct rtable *rt;
 513         struct flowi4 fl4;
 514
 515         rt = lisp_get_rt(skb, dev, &fl4, &info->key);
 516         if (IS_ERR(rt))
 517                 return PTR_ERR(rt);
 518         ip_rt_put(rt);
 519
 520         info->key.u.ipv4.src = fl4.saddr;
 521         info->key.tp_src = sport;
 522         info->key.tp_dst = dport;
 523         return 0;
 524 }
 525
 526 int ovs_lisp_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
 527 {
 528         struct lisp_dev *lisp = netdev_priv(dev);
 529         struct net *net = lisp->net;
 530         struct ip_tunnel_info *info = skb_tunnel_info(skb);
 531         __be16 sport, dport;
 532
 533         sport = htons(get_src_port(net, skb));
 534         dport = lisp->dst_port;
 535
 536         if (ip_tunnel_info_af(info) == AF_INET)
 537                 return egress_ipv4_tun_info(dev, skb, info, sport, dport);
 538         return -EINVAL;
 539 }
 540 EXPORT_SYMBOL_GPL(ovs_lisp_fill_metadata_dst);
 541
 542 static const struct net_device_ops lisp_netdev_ops = {
 543         .ndo_init               = lisp_init,
 544         .ndo_uninit             = lisp_uninit,
 545         .ndo_get_stats64        = ip_tunnel_get_stats64,
 546         .ndo_open               = lisp_open,
 547         .ndo_stop               = lisp_stop,
 548         .ndo_start_xmit         = lisp_dev_xmit,
 549 #ifdef  HAVE_RHEL7_MAX_MTU
 550         .extended.ndo_change_mtu = lisp_change_mtu,
 551 #else
 552         .ndo_change_mtu         = lisp_change_mtu,
 553 #endif
 554         .ndo_validate_addr      = eth_validate_addr,
 555         .ndo_set_mac_address    = eth_mac_addr,
 556 #ifdef USE_UPSTREAM_TUNNEL
 557 #ifdef HAVE_NDO_FILL_METADATA_DST
 558         .ndo_fill_metadata_dst  = lisp_fill_metadata_dst,
 559 #endif
 560 #endif
 561 };
 562
 563 static void lisp_get_drvinfo(struct net_device *dev,
 564                 struct ethtool_drvinfo *drvinfo)
 565 {
 566         strlcpy(drvinfo->version, LISP_NETDEV_VER, sizeof(drvinfo->version));
 567         strlcpy(drvinfo->driver, "lisp", sizeof(drvinfo->driver));
 568 }
 569
 570 static const struct ethtool_ops lisp_ethtool_ops = {
 571         .get_drvinfo    = lisp_get_drvinfo,
 572         .get_link       = ethtool_op_get_link,
 573 };
 574
 575 /* Info for udev, that this is a virtual tunnel endpoint */
 576 static struct device_type lisp_type = {
 577         .name = "lisp",
 578 };
 579
 580 /* Initialize the device structure. */
 581 static void lisp_setup(struct net_device *dev)
 582 {
 583         ether_setup(dev);
 584
 585         dev->netdev_ops = &lisp_netdev_ops;
 586         dev->ethtool_ops = &lisp_ethtool_ops;
 587 #ifndef HAVE_NEEDS_FREE_NETDEV
 588         dev->destructor = free_netdev;
 589 #else
 590         dev->needs_free_netdev = true;
 591 #endif
 592
 593         SET_NETDEV_DEVTYPE(dev, &lisp_type);
 594
 595         dev->features    |= NETIF_F_LLTX | NETIF_F_NETNS_LOCAL;
 596         dev->features    |= NETIF_F_SG | NETIF_F_HW_CSUM;
 597         dev->features    |= NETIF_F_RXCSUM;
 598         dev->features    |= NETIF_F_GSO_SOFTWARE;
 599
 600 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
 601         dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
 602         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 603 #endif
 604 #ifdef USE_UPSTREAM_TUNNEL
 605         netif_keep_dst(dev);
 606 #endif
 607         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
 608         eth_hw_addr_random(dev);
 609 }
 610
 611 static const struct nla_policy lisp_policy[IFLA_LISP_MAX + 1] = {
 612         [IFLA_LISP_PORT]              = { .type = NLA_U16 },
 613 };
 614
 615 #ifdef HAVE_EXT_ACK_IN_RTNL_LINKOPS
 616 static int lisp_validate(struct nlattr *tb[], struct nlattr *data[],
 617                          struct netlink_ext_ack __always_unused *extack)
 618 #else
 619 static int lisp_validate(struct nlattr *tb[], struct nlattr *data[])
 620 #endif
 621 {
 622         if (tb[IFLA_ADDRESS]) {
 623                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 624                         return -EINVAL;
 625
 626                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 627                         return -EADDRNOTAVAIL;
 628         }
 629
 630         return 0;
 631 }
 632
 633 static struct lisp_dev *find_dev(struct net *net, __be16 dst_port)
 634 {
 635         struct lisp_net *ln = net_generic(net, lisp_net_id);
 636         struct lisp_dev *dev;
 637
 638         list_for_each_entry(dev, &ln->lisp_list, next) {
 639                 if (dev->dst_port == dst_port)
 640                         return dev;
 641         }
 642         return NULL;
 643 }
 644
 645 static int lisp_configure(struct net *net, struct net_device *dev,
 646                           __be16 dst_port)
 647 {
 648         struct lisp_net *ln = net_generic(net, lisp_net_id);
 649         struct lisp_dev *lisp = netdev_priv(dev);
 650         int err;
 651
 652         lisp->net = net;
 653         lisp->dev = dev;
 654
 655         lisp->dst_port = dst_port;
 656
 657         if (find_dev(net, dst_port))
 658                 return -EBUSY;
 659
 660         err = lisp_change_mtu(dev, LISP_MAX_MTU);
 661         if (err)
 662                 return err;
 663
 664         err = register_netdevice(dev);
 665         if (err)
 666                 return err;
 667
 668         list_add(&lisp->next, &ln->lisp_list);
 669         return 0;
 670 }
 671
 672 #ifdef HAVE_EXT_ACK_IN_RTNL_LINKOPS
 673 static int lisp_newlink(struct net *net, struct net_device *dev,
 674                 struct nlattr *tb[], struct nlattr *data[],
 675                 struct netlink_ext_ack __always_unused *extack)
 676 #else
 677 static int lisp_newlink(struct net *net, struct net_device *dev,
 678                 struct nlattr *tb[], struct nlattr *data[])
 679 #endif
 680 {
 681         __be16 dst_port = htons(LISP_UDP_PORT);
 682
 683         if (data[IFLA_LISP_PORT])
 684                 dst_port = nla_get_be16(data[IFLA_LISP_PORT]);
 685
 686         return lisp_configure(net, dev, dst_port);
 687 }
 688
 689 static void lisp_dellink(struct net_device *dev, struct list_head *head)
 690 {
 691         struct lisp_dev *lisp = netdev_priv(dev);
 692
 693         list_del(&lisp->next);
 694         unregister_netdevice_queue(dev, head);
 695 }
 696
 697 static size_t lisp_get_size(const struct net_device *dev)
 698 {
 699         return nla_total_size(sizeof(__be32));  /* IFLA_LISP_PORT */
 700 }
 701
 702 static int lisp_fill_info(struct sk_buff *skb, const struct net_device *dev)
 703 {
 704         struct lisp_dev *lisp = netdev_priv(dev);
 705
 706         if (nla_put_be16(skb, IFLA_LISP_PORT, lisp->dst_port))
 707                 goto nla_put_failure;
 708
 709         return 0;
 710
 711 nla_put_failure:
 712         return -EMSGSIZE;
 713 }
 714
 715 static struct rtnl_link_ops lisp_link_ops __read_mostly = {
 716         .kind           = "lisp",
 717         .maxtype        = IFLA_LISP_MAX,
 718         .policy         = lisp_policy,
 719         .priv_size      = sizeof(struct lisp_dev),
 720         .setup          = lisp_setup,
 721         .validate       = lisp_validate,
 722         .newlink        = lisp_newlink,
 723         .dellink        = lisp_dellink,
 724         .get_size       = lisp_get_size,
 725         .fill_info      = lisp_fill_info,
 726 };
 727
 728 struct net_device *rpl_lisp_dev_create_fb(struct net *net, const char *name,
 729                                       u8 name_assign_type, u16 dst_port)
 730 {
 731         struct nlattr *tb[IFLA_MAX + 1];
 732         struct net_device *dev;
 733         int err;
 734
 735         memset(tb, 0, sizeof(tb));
 736         dev = rtnl_create_link(net, (char *) name, name_assign_type,
 737                         &lisp_link_ops, tb);
 738         if (IS_ERR(dev))
 739                 return dev;
 740
 741         err = lisp_configure(net, dev, htons(dst_port));
 742         if (err) {
 743                 free_netdev(dev);
 744                 return ERR_PTR(err);
 745         }
 746         return dev;
 747 }
 748 EXPORT_SYMBOL_GPL(rpl_lisp_dev_create_fb);
 749
 750 static int lisp_init_net(struct net *net)
 751 {
 752         struct lisp_net *ln = net_generic(net, lisp_net_id);
 753
 754         INIT_LIST_HEAD(&ln->lisp_list);
 755         return 0;
 756 }
 757
 758 static void lisp_exit_net(struct net *net)
 759 {
 760         struct lisp_net *ln = net_generic(net, lisp_net_id);
 761         struct lisp_dev *lisp, *next;
 762         struct net_device *dev, *aux;
 763         LIST_HEAD(list);
 764
 765         rtnl_lock();
 766
 767         /* gather any lisp devices that were moved into this ns */
 768         for_each_netdev_safe(net, dev, aux)
 769                 if (dev->rtnl_link_ops == &lisp_link_ops)
 770                         unregister_netdevice_queue(dev, &list);
 771
 772         list_for_each_entry_safe(lisp, next, &ln->lisp_list, next) {
 773                 /* If lisp->dev is in the same netns, it was already added
 774                  * to the lisp by the previous loop.
 775                  */
 776                 if (!net_eq(dev_net(lisp->dev), net))
 777                         unregister_netdevice_queue(lisp->dev, &list);
 778         }
 779
 780         /* unregister the devices gathered above */
 781         unregister_netdevice_many(&list);
 782         rtnl_unlock();
 783 }
 784
 785 static struct pernet_operations lisp_net_ops = {
 786         .init = lisp_init_net,
 787         .exit = lisp_exit_net,
 788         .id   = &lisp_net_id,
 789         .size = sizeof(struct lisp_net),
 790 };
 791
 792 int rpl_lisp_init_module(void)
 793 {
 794         int rc;
 795
 796         rc = register_pernet_subsys(&lisp_net_ops);
 797         if (rc)
 798                 goto out1;
 799
 800         rc = rtnl_link_register(&lisp_link_ops);
 801         if (rc)
 802                 goto out2;
 803
 804         pr_info("LISP tunneling driver\n");
 805         return 0;
 806 out2:
 807         unregister_pernet_subsys(&lisp_net_ops);
 808 out1:
 809         pr_err("Error while initializing LISP %d\n", rc);
 810         return rc;
 811 }
 812
 813 void rpl_lisp_cleanup_module(void)
 814 {
 815         rtnl_link_unregister(&lisp_link_ops);
 816         unregister_pernet_subsys(&lisp_net_ops);
 817 }