drivers/net/ipvlan/ipvlan_main.c

   1 /* Copyright (c) 2014 Mahesh Bandewar <maheshb@google.com>
   2  *
   3  * This program is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU General Public License as
   5  * published by the Free Software Foundation; either version 2 of
   6  * the License, or (at your option) any later version.
   7  *
   8  */
   9
  10 #include "ipvlan.h"
  11
  12 static u32 ipvl_nf_hook_refcnt = 0;
  13
  14 static struct nf_hook_ops ipvl_nfops[] __read_mostly = {
  15         {
  16                 .hook     = ipvlan_nf_input,
  17                 .pf       = NFPROTO_IPV4,
  18                 .hooknum  = NF_INET_LOCAL_IN,
  19                 .priority = INT_MAX,
  20         },
  21         {
  22                 .hook     = ipvlan_nf_input,
  23                 .pf       = NFPROTO_IPV6,
  24                 .hooknum  = NF_INET_LOCAL_IN,
  25                 .priority = INT_MAX,
  26         },
  27 };
  28
  29 static const struct l3mdev_ops ipvl_l3mdev_ops = {
  30         .l3mdev_l3_rcv = ipvlan_l3_rcv,
  31 };
  32
  33 static void ipvlan_adjust_mtu(struct ipvl_dev *ipvlan, struct net_device *dev)
  34 {
  35         ipvlan->dev->mtu = dev->mtu;
  36 }
  37
  38 static int ipvlan_register_nf_hook(void)
  39 {
  40         int err = 0;
  41
  42         if (!ipvl_nf_hook_refcnt) {
  43                 err = _nf_register_hooks(ipvl_nfops, ARRAY_SIZE(ipvl_nfops));
  44                 if (!err)
  45                         ipvl_nf_hook_refcnt = 1;
  46         } else {
  47                 ipvl_nf_hook_refcnt++;
  48         }
  49
  50         return err;
  51 }
  52
  53 static void ipvlan_unregister_nf_hook(void)
  54 {
  55         WARN_ON(!ipvl_nf_hook_refcnt);
  56
  57         ipvl_nf_hook_refcnt--;
  58         if (!ipvl_nf_hook_refcnt)
  59                 _nf_unregister_hooks(ipvl_nfops, ARRAY_SIZE(ipvl_nfops));
  60 }
  61
  62 static int ipvlan_set_port_mode(struct ipvl_port *port, u16 nval)
  63 {
  64         struct ipvl_dev *ipvlan;
  65         struct net_device *mdev = port->dev;
  66         int err = 0;
  67
  68         ASSERT_RTNL();
  69         if (port->mode != nval) {
  70                 if (nval == IPVLAN_MODE_L3S) {
  71                         /* New mode is L3S */
  72                         err = ipvlan_register_nf_hook();
  73                         if (!err) {
  74                                 mdev->l3mdev_ops = &ipvl_l3mdev_ops;
  75                                 mdev->priv_flags |= IFF_L3MDEV_MASTER;
  76                         } else
  77                                 return err;
  78                 } else if (port->mode == IPVLAN_MODE_L3S) {
  79                         /* Old mode was L3S */
  80                         mdev->priv_flags &= ~IFF_L3MDEV_MASTER;
  81                         ipvlan_unregister_nf_hook();
  82                         mdev->l3mdev_ops = NULL;
  83                 }
  84                 list_for_each_entry(ipvlan, &port->ipvlans, pnode) {
  85                         if (nval == IPVLAN_MODE_L3 || nval == IPVLAN_MODE_L3S)
  86                                 ipvlan->dev->flags |= IFF_NOARP;
  87                         else
  88                                 ipvlan->dev->flags &= ~IFF_NOARP;
  89                 }
  90                 port->mode = nval;
  91         }
  92         return err;
  93 }
  94
  95 static int ipvlan_port_create(struct net_device *dev)
  96 {
  97         struct ipvl_port *port;
  98         int err, idx;
  99
 100         if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK) {
 101                 netdev_err(dev, "Master is either lo or non-ether device\n");
 102                 return -EINVAL;
 103         }
 104
 105         if (netif_is_macvlan_port(dev)) {
 106                 netdev_err(dev, "Master is a macvlan port.\n");
 107                 return -EBUSY;
 108         }
 109
 110         port = kzalloc(sizeof(struct ipvl_port), GFP_KERNEL);
 111         if (!port)
 112                 return -ENOMEM;
 113
 114         port->dev = dev;
 115         port->mode = IPVLAN_MODE_L3;
 116         INIT_LIST_HEAD(&port->ipvlans);
 117         for (idx = 0; idx < IPVLAN_HASH_SIZE; idx++)
 118                 INIT_HLIST_HEAD(&port->hlhead[idx]);
 119
 120         skb_queue_head_init(&port->backlog);
 121         INIT_WORK(&port->wq, ipvlan_process_multicast);
 122
 123         err = netdev_rx_handler_register(dev, ipvlan_handle_frame, port);
 124         if (err)
 125                 goto err;
 126
 127         dev->priv_flags |= IFF_IPVLAN_MASTER;
 128         return 0;
 129
 130 err:
 131         kfree(port);
 132         return err;
 133 }
 134
 135 static void ipvlan_port_destroy(struct net_device *dev)
 136 {
 137         struct ipvl_port *port = ipvlan_port_get_rtnl(dev);
 138         struct sk_buff *skb;
 139
 140         dev->priv_flags &= ~IFF_IPVLAN_MASTER;
 141         if (port->mode == IPVLAN_MODE_L3S) {
 142                 dev->priv_flags &= ~IFF_L3MDEV_MASTER;
 143                 ipvlan_unregister_nf_hook();
 144                 dev->l3mdev_ops = NULL;
 145         }
 146         netdev_rx_handler_unregister(dev);
 147         cancel_work_sync(&port->wq);
 148         while ((skb = __skb_dequeue(&port->backlog)) != NULL) {
 149                 if (skb->dev)
 150                         dev_put(skb->dev);
 151                 kfree_skb(skb);
 152         }
 153         kfree(port);
 154 }
 155
 156 #define IPVLAN_FEATURES \
 157         (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
 158          NETIF_F_GSO | NETIF_F_TSO | NETIF_F_UFO | NETIF_F_GSO_ROBUST | \
 159          NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \
 160          NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)
 161
 162 #define IPVLAN_STATE_MASK \
 163         ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT))
 164
 165 static int ipvlan_init(struct net_device *dev)
 166 {
 167         struct ipvl_dev *ipvlan = netdev_priv(dev);
 168         const struct net_device *phy_dev = ipvlan->phy_dev;
 169         struct ipvl_port *port = ipvlan->port;
 170
 171         dev->state = (dev->state & ~IPVLAN_STATE_MASK) |
 172                      (phy_dev->state & IPVLAN_STATE_MASK);
 173         dev->features = phy_dev->features & IPVLAN_FEATURES;
 174         dev->features |= NETIF_F_LLTX;
 175         dev->gso_max_size = phy_dev->gso_max_size;
 176         dev->gso_max_segs = phy_dev->gso_max_segs;
 177         dev->hard_header_len = phy_dev->hard_header_len;
 178
 179         netdev_lockdep_set_classes(dev);
 180
 181         ipvlan->pcpu_stats = alloc_percpu(struct ipvl_pcpu_stats);
 182         if (!ipvlan->pcpu_stats)
 183                 return -ENOMEM;
 184
 185         port->count += 1;
 186
 187         return 0;
 188 }
 189
 190 static void ipvlan_uninit(struct net_device *dev)
 191 {
 192         struct ipvl_dev *ipvlan = netdev_priv(dev);
 193         struct ipvl_port *port = ipvlan->port;
 194
 195         free_percpu(ipvlan->pcpu_stats);
 196
 197         port->count -= 1;
 198         if (!port->count)
 199                 ipvlan_port_destroy(port->dev);
 200 }
 201
 202 static int ipvlan_open(struct net_device *dev)
 203 {
 204         struct ipvl_dev *ipvlan = netdev_priv(dev);
 205         struct net_device *phy_dev = ipvlan->phy_dev;
 206         struct ipvl_addr *addr;
 207
 208         if (ipvlan->port->mode == IPVLAN_MODE_L3 ||
 209             ipvlan->port->mode == IPVLAN_MODE_L3S)
 210                 dev->flags |= IFF_NOARP;
 211         else
 212                 dev->flags &= ~IFF_NOARP;
 213
 214         list_for_each_entry(addr, &ipvlan->addrs, anode)
 215                 ipvlan_ht_addr_add(ipvlan, addr);
 216
 217         return dev_uc_add(phy_dev, phy_dev->dev_addr);
 218 }
 219
 220 static int ipvlan_stop(struct net_device *dev)
 221 {
 222         struct ipvl_dev *ipvlan = netdev_priv(dev);
 223         struct net_device *phy_dev = ipvlan->phy_dev;
 224         struct ipvl_addr *addr;
 225
 226         dev_uc_unsync(phy_dev, dev);
 227         dev_mc_unsync(phy_dev, dev);
 228
 229         dev_uc_del(phy_dev, phy_dev->dev_addr);
 230
 231         list_for_each_entry(addr, &ipvlan->addrs, anode)
 232                 ipvlan_ht_addr_del(addr);
 233
 234         return 0;
 235 }
 236
 237 static netdev_tx_t ipvlan_start_xmit(struct sk_buff *skb,
 238                                      struct net_device *dev)
 239 {
 240         const struct ipvl_dev *ipvlan = netdev_priv(dev);
 241         int skblen = skb->len;
 242         int ret;
 243
 244         ret = ipvlan_queue_xmit(skb, dev);
 245         if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
 246                 struct ipvl_pcpu_stats *pcptr;
 247
 248                 pcptr = this_cpu_ptr(ipvlan->pcpu_stats);
 249
 250                 u64_stats_update_begin(&pcptr->syncp);
 251                 pcptr->tx_pkts++;
 252                 pcptr->tx_bytes += skblen;
 253                 u64_stats_update_end(&pcptr->syncp);
 254         } else {
 255                 this_cpu_inc(ipvlan->pcpu_stats->tx_drps);
 256         }
 257         return ret;
 258 }
 259
 260 static netdev_features_t ipvlan_fix_features(struct net_device *dev,
 261                                              netdev_features_t features)
 262 {
 263         struct ipvl_dev *ipvlan = netdev_priv(dev);
 264
 265         return features & (ipvlan->sfeatures | ~IPVLAN_FEATURES);
 266 }
 267
 268 static void ipvlan_change_rx_flags(struct net_device *dev, int change)
 269 {
 270         struct ipvl_dev *ipvlan = netdev_priv(dev);
 271         struct net_device *phy_dev = ipvlan->phy_dev;
 272
 273         if (change & IFF_ALLMULTI)
 274                 dev_set_allmulti(phy_dev, dev->flags & IFF_ALLMULTI? 1 : -1);
 275 }
 276
 277 static void ipvlan_set_multicast_mac_filter(struct net_device *dev)
 278 {
 279         struct ipvl_dev *ipvlan = netdev_priv(dev);
 280
 281         if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
 282                 bitmap_fill(ipvlan->mac_filters, IPVLAN_MAC_FILTER_SIZE);
 283         } else {
 284                 struct netdev_hw_addr *ha;
 285                 DECLARE_BITMAP(mc_filters, IPVLAN_MAC_FILTER_SIZE);
 286
 287                 bitmap_zero(mc_filters, IPVLAN_MAC_FILTER_SIZE);
 288                 netdev_for_each_mc_addr(ha, dev)
 289                         __set_bit(ipvlan_mac_hash(ha->addr), mc_filters);
 290
 291                 /* Turn-on broadcast bit irrespective of address family,
 292                  * since broadcast is deferred to a work-queue, hence no
 293                  * impact on fast-path processing.
 294                  */
 295                 __set_bit(ipvlan_mac_hash(dev->broadcast), mc_filters);
 296
 297                 bitmap_copy(ipvlan->mac_filters, mc_filters,
 298                             IPVLAN_MAC_FILTER_SIZE);
 299         }
 300         dev_uc_sync(ipvlan->phy_dev, dev);
 301         dev_mc_sync(ipvlan->phy_dev, dev);
 302 }
 303
 304 static struct rtnl_link_stats64 *ipvlan_get_stats64(struct net_device *dev,
 305                                                     struct rtnl_link_stats64 *s)
 306 {
 307         struct ipvl_dev *ipvlan = netdev_priv(dev);
 308
 309         if (ipvlan->pcpu_stats) {
 310                 struct ipvl_pcpu_stats *pcptr;
 311                 u64 rx_pkts, rx_bytes, rx_mcast, tx_pkts, tx_bytes;
 312                 u32 rx_errs = 0, tx_drps = 0;
 313                 u32 strt;
 314                 int idx;
 315
 316                 for_each_possible_cpu(idx) {
 317                         pcptr = per_cpu_ptr(ipvlan->pcpu_stats, idx);
 318                         do {
 319                                 strt= u64_stats_fetch_begin_irq(&pcptr->syncp);
 320                                 rx_pkts = pcptr->rx_pkts;
 321                                 rx_bytes = pcptr->rx_bytes;
 322                                 rx_mcast = pcptr->rx_mcast;
 323                                 tx_pkts = pcptr->tx_pkts;
 324                                 tx_bytes = pcptr->tx_bytes;
 325                         } while (u64_stats_fetch_retry_irq(&pcptr->syncp,
 326                                                            strt));
 327
 328                         s->rx_packets += rx_pkts;
 329                         s->rx_bytes += rx_bytes;
 330                         s->multicast += rx_mcast;
 331                         s->tx_packets += tx_pkts;
 332                         s->tx_bytes += tx_bytes;
 333
 334                         /* u32 values are updated without syncp protection. */
 335                         rx_errs += pcptr->rx_errs;
 336                         tx_drps += pcptr->tx_drps;
 337                 }
 338                 s->rx_errors = rx_errs;
 339                 s->rx_dropped = rx_errs;
 340                 s->tx_dropped = tx_drps;
 341         }
 342         return s;
 343 }
 344
 345 static int ipvlan_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid)
 346 {
 347         struct ipvl_dev *ipvlan = netdev_priv(dev);
 348         struct net_device *phy_dev = ipvlan->phy_dev;
 349
 350         return vlan_vid_add(phy_dev, proto, vid);
 351 }
 352
 353 static int ipvlan_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,
 354                                    u16 vid)
 355 {
 356         struct ipvl_dev *ipvlan = netdev_priv(dev);
 357         struct net_device *phy_dev = ipvlan->phy_dev;
 358
 359         vlan_vid_del(phy_dev, proto, vid);
 360         return 0;
 361 }
 362
 363 static int ipvlan_get_iflink(const struct net_device *dev)
 364 {
 365         struct ipvl_dev *ipvlan = netdev_priv(dev);
 366
 367         return ipvlan->phy_dev->ifindex;
 368 }
 369
 370 static const struct net_device_ops ipvlan_netdev_ops = {
 371         .ndo_init               = ipvlan_init,
 372         .ndo_uninit             = ipvlan_uninit,
 373         .ndo_open               = ipvlan_open,
 374         .ndo_stop               = ipvlan_stop,
 375         .ndo_start_xmit         = ipvlan_start_xmit,
 376         .ndo_fix_features       = ipvlan_fix_features,
 377         .ndo_change_rx_flags    = ipvlan_change_rx_flags,
 378         .ndo_set_rx_mode        = ipvlan_set_multicast_mac_filter,
 379         .ndo_get_stats64        = ipvlan_get_stats64,
 380         .ndo_vlan_rx_add_vid    = ipvlan_vlan_rx_add_vid,
 381         .ndo_vlan_rx_kill_vid   = ipvlan_vlan_rx_kill_vid,
 382         .ndo_get_iflink         = ipvlan_get_iflink,
 383 };
 384
 385 static int ipvlan_hard_header(struct sk_buff *skb, struct net_device *dev,
 386                               unsigned short type, const void *daddr,
 387                               const void *saddr, unsigned len)
 388 {
 389         const struct ipvl_dev *ipvlan = netdev_priv(dev);
 390         struct net_device *phy_dev = ipvlan->phy_dev;
 391
 392         /* TODO Probably use a different field than dev_addr so that the
 393          * mac-address on the virtual device is portable and can be carried
 394          * while the packets use the mac-addr on the physical device.
 395          */
 396         return dev_hard_header(skb, phy_dev, type, daddr,
 397                                saddr ? : dev->dev_addr, len);
 398 }
 399
 400 static const struct header_ops ipvlan_header_ops = {
 401         .create         = ipvlan_hard_header,
 402         .parse          = eth_header_parse,
 403         .cache          = eth_header_cache,
 404         .cache_update   = eth_header_cache_update,
 405 };
 406
 407 static int ipvlan_ethtool_get_link_ksettings(struct net_device *dev,
 408                                              struct ethtool_link_ksettings *cmd)
 409 {
 410         const struct ipvl_dev *ipvlan = netdev_priv(dev);
 411
 412         return __ethtool_get_link_ksettings(ipvlan->phy_dev, cmd);
 413 }
 414
 415 static void ipvlan_ethtool_get_drvinfo(struct net_device *dev,
 416                                        struct ethtool_drvinfo *drvinfo)
 417 {
 418         strlcpy(drvinfo->driver, IPVLAN_DRV, sizeof(drvinfo->driver));
 419         strlcpy(drvinfo->version, IPV_DRV_VER, sizeof(drvinfo->version));
 420 }
 421
 422 static u32 ipvlan_ethtool_get_msglevel(struct net_device *dev)
 423 {
 424         const struct ipvl_dev *ipvlan = netdev_priv(dev);
 425
 426         return ipvlan->msg_enable;
 427 }
 428
 429 static void ipvlan_ethtool_set_msglevel(struct net_device *dev, u32 value)
 430 {
 431         struct ipvl_dev *ipvlan = netdev_priv(dev);
 432
 433         ipvlan->msg_enable = value;
 434 }
 435
 436 static const struct ethtool_ops ipvlan_ethtool_ops = {
 437         .get_link       = ethtool_op_get_link,
 438         .get_link_ksettings     = ipvlan_ethtool_get_link_ksettings,
 439         .get_drvinfo    = ipvlan_ethtool_get_drvinfo,
 440         .get_msglevel   = ipvlan_ethtool_get_msglevel,
 441         .set_msglevel   = ipvlan_ethtool_set_msglevel,
 442 };
 443
 444 static int ipvlan_nl_changelink(struct net_device *dev,
 445                                 struct nlattr *tb[], struct nlattr *data[])
 446 {
 447         struct ipvl_dev *ipvlan = netdev_priv(dev);
 448         struct ipvl_port *port = ipvlan_port_get_rtnl(ipvlan->phy_dev);
 449         int err = 0;
 450
 451         if (data && data[IFLA_IPVLAN_MODE]) {
 452                 u16 nmode = nla_get_u16(data[IFLA_IPVLAN_MODE]);
 453
 454                 err = ipvlan_set_port_mode(port, nmode);
 455         }
 456         return err;
 457 }
 458
 459 static size_t ipvlan_nl_getsize(const struct net_device *dev)
 460 {
 461         return (0
 462                 + nla_total_size(2) /* IFLA_IPVLAN_MODE */
 463                 );
 464 }
 465
 466 static int ipvlan_nl_validate(struct nlattr *tb[], struct nlattr *data[])
 467 {
 468         if (data && data[IFLA_IPVLAN_MODE]) {
 469                 u16 mode = nla_get_u16(data[IFLA_IPVLAN_MODE]);
 470
 471                 if (mode < IPVLAN_MODE_L2 || mode >= IPVLAN_MODE_MAX)
 472                         return -EINVAL;
 473         }
 474         return 0;
 475 }
 476
 477 static int ipvlan_nl_fillinfo(struct sk_buff *skb,
 478                               const struct net_device *dev)
 479 {
 480         struct ipvl_dev *ipvlan = netdev_priv(dev);
 481         struct ipvl_port *port = ipvlan_port_get_rtnl(ipvlan->phy_dev);
 482         int ret = -EINVAL;
 483
 484         if (!port)
 485                 goto err;
 486
 487         ret = -EMSGSIZE;
 488         if (nla_put_u16(skb, IFLA_IPVLAN_MODE, port->mode))
 489                 goto err;
 490
 491         return 0;
 492
 493 err:
 494         return ret;
 495 }
 496
 497 static int ipvlan_link_new(struct net *src_net, struct net_device *dev,
 498                            struct nlattr *tb[], struct nlattr *data[])
 499 {
 500         struct ipvl_dev *ipvlan = netdev_priv(dev);
 501         struct ipvl_port *port;
 502         struct net_device *phy_dev;
 503         int err;
 504         u16 mode = IPVLAN_MODE_L3;
 505         bool create = false;
 506
 507         if (!tb[IFLA_LINK])
 508                 return -EINVAL;
 509
 510         phy_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
 511         if (!phy_dev)
 512                 return -ENODEV;
 513
 514         if (netif_is_ipvlan(phy_dev)) {
 515                 struct ipvl_dev *tmp = netdev_priv(phy_dev);
 516
 517                 phy_dev = tmp->phy_dev;
 518         } else if (!netif_is_ipvlan_port(phy_dev)) {
 519                 err = ipvlan_port_create(phy_dev);
 520                 if (err < 0)
 521                         return err;
 522                 create = true;
 523         }
 524
 525         if (data && data[IFLA_IPVLAN_MODE])
 526                 mode = nla_get_u16(data[IFLA_IPVLAN_MODE]);
 527
 528         port = ipvlan_port_get_rtnl(phy_dev);
 529         ipvlan->phy_dev = phy_dev;
 530         ipvlan->dev = dev;
 531         ipvlan->port = port;
 532         ipvlan->sfeatures = IPVLAN_FEATURES;
 533         ipvlan_adjust_mtu(ipvlan, phy_dev);
 534         INIT_LIST_HEAD(&ipvlan->addrs);
 535
 536         /* TODO Probably put random address here to be presented to the
 537          * world but keep using the physical-dev address for the outgoing
 538          * packets.
 539          */
 540         memcpy(dev->dev_addr, phy_dev->dev_addr, ETH_ALEN);
 541
 542         dev->priv_flags |= IFF_IPVLAN_SLAVE;
 543
 544         err = register_netdevice(dev);
 545         if (err < 0)
 546                 goto destroy_ipvlan_port;
 547
 548         err = netdev_upper_dev_link(phy_dev, dev);
 549         if (err) {
 550                 goto unregister_netdev;
 551         }
 552         err = ipvlan_set_port_mode(port, mode);
 553         if (err) {
 554                 goto unlink_netdev;
 555         }
 556
 557         list_add_tail_rcu(&ipvlan->pnode, &port->ipvlans);
 558         netif_stacked_transfer_operstate(phy_dev, dev);
 559         return 0;
 560
 561 unlink_netdev:
 562         netdev_upper_dev_unlink(phy_dev, dev);
 563 unregister_netdev:
 564         unregister_netdevice(dev);
 565 destroy_ipvlan_port:
 566         if (create)
 567                 ipvlan_port_destroy(phy_dev);
 568         return err;
 569 }
 570
 571 static void ipvlan_link_delete(struct net_device *dev, struct list_head *head)
 572 {
 573         struct ipvl_dev *ipvlan = netdev_priv(dev);
 574         struct ipvl_addr *addr, *next;
 575
 576         list_for_each_entry_safe(addr, next, &ipvlan->addrs, anode) {
 577                 ipvlan_ht_addr_del(addr);
 578                 list_del(&addr->anode);
 579                 kfree_rcu(addr, rcu);
 580         }
 581
 582         list_del_rcu(&ipvlan->pnode);
 583         unregister_netdevice_queue(dev, head);
 584         netdev_upper_dev_unlink(ipvlan->phy_dev, dev);
 585 }
 586
 587 static void ipvlan_link_setup(struct net_device *dev)
 588 {
 589         ether_setup(dev);
 590
 591         dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
 592         dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE;
 593         dev->netdev_ops = &ipvlan_netdev_ops;
 594         dev->destructor = free_netdev;
 595         dev->header_ops = &ipvlan_header_ops;
 596         dev->ethtool_ops = &ipvlan_ethtool_ops;
 597 }
 598
 599 static const struct nla_policy ipvlan_nl_policy[IFLA_IPVLAN_MAX + 1] =
 600 {
 601         [IFLA_IPVLAN_MODE] = { .type = NLA_U16 },
 602 };
 603
 604 static struct rtnl_link_ops ipvlan_link_ops = {
 605         .kind           = "ipvlan",
 606         .priv_size      = sizeof(struct ipvl_dev),
 607
 608         .get_size       = ipvlan_nl_getsize,
 609         .policy         = ipvlan_nl_policy,
 610         .validate       = ipvlan_nl_validate,
 611         .fill_info      = ipvlan_nl_fillinfo,
 612         .changelink     = ipvlan_nl_changelink,
 613         .maxtype        = IFLA_IPVLAN_MAX,
 614
 615         .setup          = ipvlan_link_setup,
 616         .newlink        = ipvlan_link_new,
 617         .dellink        = ipvlan_link_delete,
 618 };
 619
 620 static int ipvlan_link_register(struct rtnl_link_ops *ops)
 621 {
 622         return rtnl_link_register(ops);
 623 }
 624
 625 static int ipvlan_device_event(struct notifier_block *unused,
 626                                unsigned long event, void *ptr)
 627 {
 628         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 629         struct ipvl_dev *ipvlan, *next;
 630         struct ipvl_port *port;
 631         LIST_HEAD(lst_kill);
 632
 633         if (!netif_is_ipvlan_port(dev))
 634                 return NOTIFY_DONE;
 635
 636         port = ipvlan_port_get_rtnl(dev);
 637
 638         switch (event) {
 639         case NETDEV_CHANGE:
 640                 list_for_each_entry(ipvlan, &port->ipvlans, pnode)
 641                         netif_stacked_transfer_operstate(ipvlan->phy_dev,
 642                                                          ipvlan->dev);
 643                 break;
 644
 645         case NETDEV_UNREGISTER:
 646                 if (dev->reg_state != NETREG_UNREGISTERING)
 647                         break;
 648
 649                 list_for_each_entry_safe(ipvlan, next, &port->ipvlans,
 650                                          pnode)
 651                         ipvlan->dev->rtnl_link_ops->dellink(ipvlan->dev,
 652                                                             &lst_kill);
 653                 unregister_netdevice_many(&lst_kill);
 654                 break;
 655
 656         case NETDEV_FEAT_CHANGE:
 657                 list_for_each_entry(ipvlan, &port->ipvlans, pnode) {
 658                         ipvlan->dev->features = dev->features & IPVLAN_FEATURES;
 659                         ipvlan->dev->gso_max_size = dev->gso_max_size;
 660                         ipvlan->dev->gso_max_segs = dev->gso_max_segs;
 661                         netdev_features_change(ipvlan->dev);
 662                 }
 663                 break;
 664
 665         case NETDEV_CHANGEMTU:
 666                 list_for_each_entry(ipvlan, &port->ipvlans, pnode)
 667                         ipvlan_adjust_mtu(ipvlan, dev);
 668                 break;
 669
 670         case NETDEV_PRE_TYPE_CHANGE:
 671                 /* Forbid underlying device to change its type. */
 672                 return NOTIFY_BAD;
 673         }
 674         return NOTIFY_DONE;
 675 }
 676
 677 static int ipvlan_add_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr)
 678 {
 679         struct ipvl_addr *addr;
 680
 681         if (ipvlan_addr_busy(ipvlan->port, ip6_addr, true)) {
 682                 netif_err(ipvlan, ifup, ipvlan->dev,
 683                           "Failed to add IPv6=%pI6c addr for %s intf\n",
 684                           ip6_addr, ipvlan->dev->name);
 685                 return -EINVAL;
 686         }
 687         addr = kzalloc(sizeof(struct ipvl_addr), GFP_ATOMIC);
 688         if (!addr)
 689                 return -ENOMEM;
 690
 691         addr->master = ipvlan;
 692         memcpy(&addr->ip6addr, ip6_addr, sizeof(struct in6_addr));
 693         addr->atype = IPVL_IPV6;
 694         list_add_tail(&addr->anode, &ipvlan->addrs);
 695
 696         /* If the interface is not up, the address will be added to the hash
 697          * list by ipvlan_open.
 698          */
 699         if (netif_running(ipvlan->dev))
 700                 ipvlan_ht_addr_add(ipvlan, addr);
 701
 702         return 0;
 703 }
 704
 705 static void ipvlan_del_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr)
 706 {
 707         struct ipvl_addr *addr;
 708
 709         addr = ipvlan_find_addr(ipvlan, ip6_addr, true);
 710         if (!addr)
 711                 return;
 712
 713         ipvlan_ht_addr_del(addr);
 714         list_del(&addr->anode);
 715         kfree_rcu(addr, rcu);
 716
 717         return;
 718 }
 719
 720 static int ipvlan_addr6_event(struct notifier_block *unused,
 721                               unsigned long event, void *ptr)
 722 {
 723         struct inet6_ifaddr *if6 = (struct inet6_ifaddr *)ptr;
 724         struct net_device *dev = (struct net_device *)if6->idev->dev;
 725         struct ipvl_dev *ipvlan = netdev_priv(dev);
 726
 727         /* FIXME IPv6 autoconf calls us from bh without RTNL */
 728         if (in_softirq())
 729                 return NOTIFY_DONE;
 730
 731         if (!netif_is_ipvlan(dev))
 732                 return NOTIFY_DONE;
 733
 734         if (!ipvlan || !ipvlan->port)
 735                 return NOTIFY_DONE;
 736
 737         switch (event) {
 738         case NETDEV_UP:
 739                 if (ipvlan_add_addr6(ipvlan, &if6->addr))
 740                         return NOTIFY_BAD;
 741                 break;
 742
 743         case NETDEV_DOWN:
 744                 ipvlan_del_addr6(ipvlan, &if6->addr);
 745                 break;
 746         }
 747
 748         return NOTIFY_OK;
 749 }
 750
 751 static int ipvlan_add_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr)
 752 {
 753         struct ipvl_addr *addr;
 754
 755         if (ipvlan_addr_busy(ipvlan->port, ip4_addr, false)) {
 756                 netif_err(ipvlan, ifup, ipvlan->dev,
 757                           "Failed to add IPv4=%pI4 on %s intf.\n",
 758                           ip4_addr, ipvlan->dev->name);
 759                 return -EINVAL;
 760         }
 761         addr = kzalloc(sizeof(struct ipvl_addr), GFP_KERNEL);
 762         if (!addr)
 763                 return -ENOMEM;
 764
 765         addr->master = ipvlan;
 766         memcpy(&addr->ip4addr, ip4_addr, sizeof(struct in_addr));
 767         addr->atype = IPVL_IPV4;
 768         list_add_tail(&addr->anode, &ipvlan->addrs);
 769
 770         /* If the interface is not up, the address will be added to the hash
 771          * list by ipvlan_open.
 772          */
 773         if (netif_running(ipvlan->dev))
 774                 ipvlan_ht_addr_add(ipvlan, addr);
 775
 776         return 0;
 777 }
 778
 779 static void ipvlan_del_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr)
 780 {
 781         struct ipvl_addr *addr;
 782
 783         addr = ipvlan_find_addr(ipvlan, ip4_addr, false);
 784         if (!addr)
 785                 return;
 786
 787         ipvlan_ht_addr_del(addr);
 788         list_del(&addr->anode);
 789         kfree_rcu(addr, rcu);
 790
 791         return;
 792 }
 793
 794 static int ipvlan_addr4_event(struct notifier_block *unused,
 795                               unsigned long event, void *ptr)
 796 {
 797         struct in_ifaddr *if4 = (struct in_ifaddr *)ptr;
 798         struct net_device *dev = (struct net_device *)if4->ifa_dev->dev;
 799         struct ipvl_dev *ipvlan = netdev_priv(dev);
 800         struct in_addr ip4_addr;
 801
 802         if (!netif_is_ipvlan(dev))
 803                 return NOTIFY_DONE;
 804
 805         if (!ipvlan || !ipvlan->port)
 806                 return NOTIFY_DONE;
 807
 808         switch (event) {
 809         case NETDEV_UP:
 810                 ip4_addr.s_addr = if4->ifa_address;
 811                 if (ipvlan_add_addr4(ipvlan, &ip4_addr))
 812                         return NOTIFY_BAD;
 813                 break;
 814
 815         case NETDEV_DOWN:
 816                 ip4_addr.s_addr = if4->ifa_address;
 817                 ipvlan_del_addr4(ipvlan, &ip4_addr);
 818                 break;
 819         }
 820
 821         return NOTIFY_OK;
 822 }
 823
 824 static struct notifier_block ipvlan_addr4_notifier_block __read_mostly = {
 825         .notifier_call = ipvlan_addr4_event,
 826 };
 827
 828 static struct notifier_block ipvlan_notifier_block __read_mostly = {
 829         .notifier_call = ipvlan_device_event,
 830 };
 831
 832 static struct notifier_block ipvlan_addr6_notifier_block __read_mostly = {
 833         .notifier_call = ipvlan_addr6_event,
 834 };
 835
 836 static int __init ipvlan_init_module(void)
 837 {
 838         int err;
 839
 840         ipvlan_init_secret();
 841         register_netdevice_notifier(&ipvlan_notifier_block);
 842         register_inet6addr_notifier(&ipvlan_addr6_notifier_block);
 843         register_inetaddr_notifier(&ipvlan_addr4_notifier_block);
 844
 845         err = ipvlan_link_register(&ipvlan_link_ops);
 846         if (err < 0)
 847                 goto error;
 848
 849         return 0;
 850 error:
 851         unregister_inetaddr_notifier(&ipvlan_addr4_notifier_block);
 852         unregister_inet6addr_notifier(&ipvlan_addr6_notifier_block);
 853         unregister_netdevice_notifier(&ipvlan_notifier_block);
 854         return err;
 855 }
 856
 857 static void __exit ipvlan_cleanup_module(void)
 858 {
 859         rtnl_link_unregister(&ipvlan_link_ops);
 860         unregister_netdevice_notifier(&ipvlan_notifier_block);
 861         unregister_inetaddr_notifier(&ipvlan_addr4_notifier_block);
 862         unregister_inet6addr_notifier(&ipvlan_addr6_notifier_block);
 863 }
 864
 865 module_init(ipvlan_init_module);
 866 module_exit(ipvlan_cleanup_module);
 867
 868 MODULE_LICENSE("GPL");
 869 MODULE_AUTHOR("Mahesh Bandewar <maheshb@google.com>");
 870 MODULE_DESCRIPTION("Driver for L3 (IPv6/IPv4) based VLANs");
 871 MODULE_ALIAS_RTNL_LINK("ipvlan");