drivers/net/macvlan.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (c) 2007 Patrick McHardy <kaber@trash.net>
   4  *
   5  * The code this is based on carried the following copyright notice:
   6  * ---
   7  * (C) Copyright 2001-2006
   8  * Alex Zeffertt, Cambridge Broadband Ltd, ajz@cambridgebroadband.com
   9  * Re-worked by Ben Greear <greearb@candelatech.com>
  10  * ---
  11  */
  12 #include <linux/kernel.h>
  13 #include <linux/types.h>
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/errno.h>
  17 #include <linux/slab.h>
  18 #include <linux/string.h>
  19 #include <linux/rculist.h>
  20 #include <linux/notifier.h>
  21 #include <linux/netdevice.h>
  22 #include <linux/etherdevice.h>
  23 #include <linux/net_tstamp.h>
  24 #include <linux/ethtool.h>
  25 #include <linux/if_arp.h>
  26 #include <linux/if_vlan.h>
  27 #include <linux/if_link.h>
  28 #include <linux/if_macvlan.h>
  29 #include <linux/hash.h>
  30 #include <linux/workqueue.h>
  31 #include <net/rtnetlink.h>
  32 #include <net/xfrm.h>
  33 #include <linux/netpoll.h>
  34 #include <linux/phy.h>
  35
  36 #define MACVLAN_HASH_BITS       8
  37 #define MACVLAN_HASH_SIZE       (1<<MACVLAN_HASH_BITS)
  38 #define MACVLAN_DEFAULT_BC_QUEUE_LEN    1000
  39
  40 #define MACVLAN_F_PASSTHRU      1
  41 #define MACVLAN_F_ADDRCHANGE    2
  42
  43 struct macvlan_port {
  44         struct net_device       *dev;
  45         struct hlist_head       vlan_hash[MACVLAN_HASH_SIZE];
  46         struct list_head        vlans;
  47         struct sk_buff_head     bc_queue;
  48         struct work_struct      bc_work;
  49         u32                     bc_queue_len_used;
  50         u32                     flags;
  51         int                     count;
  52         struct hlist_head       vlan_source_hash[MACVLAN_HASH_SIZE];
  53         DECLARE_BITMAP(bc_filter, MACVLAN_MC_FILTER_SZ);
  54         DECLARE_BITMAP(mc_filter, MACVLAN_MC_FILTER_SZ);
  55         unsigned char           perm_addr[ETH_ALEN];
  56 };
  57
  58 struct macvlan_source_entry {
  59         struct hlist_node       hlist;
  60         struct macvlan_dev      *vlan;
  61         unsigned char           addr[6+2] __aligned(sizeof(u16));
  62         struct rcu_head         rcu;
  63 };
  64
  65 struct macvlan_skb_cb {
  66         const struct macvlan_dev *src;
  67 };
  68
  69 #define MACVLAN_SKB_CB(__skb) ((struct macvlan_skb_cb *)&((__skb)->cb[0]))
  70
  71 static void macvlan_port_destroy(struct net_device *dev);
  72 static void update_port_bc_queue_len(struct macvlan_port *port);
  73
  74 static inline bool macvlan_passthru(const struct macvlan_port *port)
  75 {
  76         return port->flags & MACVLAN_F_PASSTHRU;
  77 }
  78
  79 static inline void macvlan_set_passthru(struct macvlan_port *port)
  80 {
  81         port->flags |= MACVLAN_F_PASSTHRU;
  82 }
  83
  84 static inline bool macvlan_addr_change(const struct macvlan_port *port)
  85 {
  86         return port->flags & MACVLAN_F_ADDRCHANGE;
  87 }
  88
  89 static inline void macvlan_set_addr_change(struct macvlan_port *port)
  90 {
  91         port->flags |= MACVLAN_F_ADDRCHANGE;
  92 }
  93
  94 static inline void macvlan_clear_addr_change(struct macvlan_port *port)
  95 {
  96         port->flags &= ~MACVLAN_F_ADDRCHANGE;
  97 }
  98
  99 /* Hash Ethernet address */
 100 static u32 macvlan_eth_hash(const unsigned char *addr)
 101 {
 102         u64 value = get_unaligned((u64 *)addr);
 103
 104         /* only want 6 bytes */
 105 #ifdef __BIG_ENDIAN
 106         value >>= 16;
 107 #else
 108         value <<= 16;
 109 #endif
 110         return hash_64(value, MACVLAN_HASH_BITS);
 111 }
 112
 113 static struct macvlan_port *macvlan_port_get_rcu(const struct net_device *dev)
 114 {
 115         return rcu_dereference(dev->rx_handler_data);
 116 }
 117
 118 static struct macvlan_port *macvlan_port_get_rtnl(const struct net_device *dev)
 119 {
 120         return rtnl_dereference(dev->rx_handler_data);
 121 }
 122
 123 static struct macvlan_dev *macvlan_hash_lookup(const struct macvlan_port *port,
 124                                                const unsigned char *addr)
 125 {
 126         struct macvlan_dev *vlan;
 127         u32 idx = macvlan_eth_hash(addr);
 128
 129         hlist_for_each_entry_rcu(vlan, &port->vlan_hash[idx], hlist,
 130                                  lockdep_rtnl_is_held()) {
 131                 if (ether_addr_equal_64bits(vlan->dev->dev_addr, addr))
 132                         return vlan;
 133         }
 134         return NULL;
 135 }
 136
 137 static struct macvlan_source_entry *macvlan_hash_lookup_source(
 138         const struct macvlan_dev *vlan,
 139         const unsigned char *addr)
 140 {
 141         struct macvlan_source_entry *entry;
 142         u32 idx = macvlan_eth_hash(addr);
 143         struct hlist_head *h = &vlan->port->vlan_source_hash[idx];
 144
 145         hlist_for_each_entry_rcu(entry, h, hlist, lockdep_rtnl_is_held()) {
 146                 if (ether_addr_equal_64bits(entry->addr, addr) &&
 147                     entry->vlan == vlan)
 148                         return entry;
 149         }
 150         return NULL;
 151 }
 152
 153 static int macvlan_hash_add_source(struct macvlan_dev *vlan,
 154                                    const unsigned char *addr)
 155 {
 156         struct macvlan_port *port = vlan->port;
 157         struct macvlan_source_entry *entry;
 158         struct hlist_head *h;
 159
 160         entry = macvlan_hash_lookup_source(vlan, addr);
 161         if (entry)
 162                 return 0;
 163
 164         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
 165         if (!entry)
 166                 return -ENOMEM;
 167
 168         ether_addr_copy(entry->addr, addr);
 169         entry->vlan = vlan;
 170         h = &port->vlan_source_hash[macvlan_eth_hash(addr)];
 171         hlist_add_head_rcu(&entry->hlist, h);
 172         vlan->macaddr_count++;
 173
 174         return 0;
 175 }
 176
 177 static void macvlan_hash_add(struct macvlan_dev *vlan)
 178 {
 179         struct macvlan_port *port = vlan->port;
 180         const unsigned char *addr = vlan->dev->dev_addr;
 181         u32 idx = macvlan_eth_hash(addr);
 182
 183         hlist_add_head_rcu(&vlan->hlist, &port->vlan_hash[idx]);
 184 }
 185
 186 static void macvlan_hash_del_source(struct macvlan_source_entry *entry)
 187 {
 188         hlist_del_rcu(&entry->hlist);
 189         kfree_rcu(entry, rcu);
 190 }
 191
 192 static void macvlan_hash_del(struct macvlan_dev *vlan, bool sync)
 193 {
 194         hlist_del_rcu(&vlan->hlist);
 195         if (sync)
 196                 synchronize_rcu();
 197 }
 198
 199 static void macvlan_hash_change_addr(struct macvlan_dev *vlan,
 200                                         const unsigned char *addr)
 201 {
 202         macvlan_hash_del(vlan, true);
 203         /* Now that we are unhashed it is safe to change the device
 204          * address without confusing packet delivery.
 205          */
 206         eth_hw_addr_set(vlan->dev, addr);
 207         macvlan_hash_add(vlan);
 208 }
 209
 210 static bool macvlan_addr_busy(const struct macvlan_port *port,
 211                               const unsigned char *addr)
 212 {
 213         /* Test to see if the specified address is
 214          * currently in use by the underlying device or
 215          * another macvlan.
 216          */
 217         if (!macvlan_passthru(port) && !macvlan_addr_change(port) &&
 218             ether_addr_equal_64bits(port->dev->dev_addr, addr))
 219                 return true;
 220
 221         if (macvlan_hash_lookup(port, addr))
 222                 return true;
 223
 224         return false;
 225 }
 226
 227
 228 static int macvlan_broadcast_one(struct sk_buff *skb,
 229                                  const struct macvlan_dev *vlan,
 230                                  const struct ethhdr *eth, bool local)
 231 {
 232         struct net_device *dev = vlan->dev;
 233
 234         if (local)
 235                 return __dev_forward_skb(dev, skb);
 236
 237         skb->dev = dev;
 238         if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast))
 239                 skb->pkt_type = PACKET_BROADCAST;
 240         else
 241                 skb->pkt_type = PACKET_MULTICAST;
 242
 243         return 0;
 244 }
 245
 246 static u32 macvlan_hash_mix(const struct macvlan_dev *vlan)
 247 {
 248         return (u32)(((unsigned long)vlan) >> L1_CACHE_SHIFT);
 249 }
 250
 251
 252 static unsigned int mc_hash(const struct macvlan_dev *vlan,
 253                             const unsigned char *addr)
 254 {
 255         u32 val = __get_unaligned_cpu32(addr + 2);
 256
 257         val ^= macvlan_hash_mix(vlan);
 258         return hash_32(val, MACVLAN_MC_FILTER_BITS);
 259 }
 260
 261 static void macvlan_broadcast(struct sk_buff *skb,
 262                               const struct macvlan_port *port,
 263                               struct net_device *src,
 264                               enum macvlan_mode mode)
 265 {
 266         const struct ethhdr *eth = eth_hdr(skb);
 267         const struct macvlan_dev *vlan;
 268         struct sk_buff *nskb;
 269         unsigned int i;
 270         int err;
 271         unsigned int hash;
 272
 273         if (skb->protocol == htons(ETH_P_PAUSE))
 274                 return;
 275
 276         hash_for_each_rcu(port->vlan_hash, i, vlan, hlist) {
 277                 if (vlan->dev == src || !(vlan->mode & mode))
 278                         continue;
 279
 280                 hash = mc_hash(vlan, eth->h_dest);
 281                 if (!test_bit(hash, vlan->mc_filter))
 282                         continue;
 283
 284                 err = NET_RX_DROP;
 285                 nskb = skb_clone(skb, GFP_ATOMIC);
 286                 if (likely(nskb))
 287                         err = macvlan_broadcast_one(nskb, vlan, eth,
 288                                         mode == MACVLAN_MODE_BRIDGE) ?:
 289                               netif_rx(nskb);
 290                 macvlan_count_rx(vlan, skb->len + ETH_HLEN,
 291                                  err == NET_RX_SUCCESS, true);
 292         }
 293 }
 294
 295 static void macvlan_multicast_rx(const struct macvlan_port *port,
 296                                  const struct macvlan_dev *src,
 297                                  struct sk_buff *skb)
 298 {
 299         if (!src)
 300                 /* frame comes from an external address */
 301                 macvlan_broadcast(skb, port, NULL,
 302                                   MACVLAN_MODE_PRIVATE |
 303                                   MACVLAN_MODE_VEPA    |
 304                                   MACVLAN_MODE_PASSTHRU|
 305                                   MACVLAN_MODE_BRIDGE);
 306         else if (src->mode == MACVLAN_MODE_VEPA)
 307                 /* flood to everyone except source */
 308                 macvlan_broadcast(skb, port, src->dev,
 309                                   MACVLAN_MODE_VEPA |
 310                                   MACVLAN_MODE_BRIDGE);
 311         else
 312                 /*
 313                  * flood only to VEPA ports, bridge ports
 314                  * already saw the frame on the way out.
 315                  */
 316                 macvlan_broadcast(skb, port, src->dev,
 317                                   MACVLAN_MODE_VEPA);
 318 }
 319
 320 static void macvlan_process_broadcast(struct work_struct *w)
 321 {
 322         struct macvlan_port *port = container_of(w, struct macvlan_port,
 323                                                  bc_work);
 324         struct sk_buff *skb;
 325         struct sk_buff_head list;
 326
 327         __skb_queue_head_init(&list);
 328
 329         spin_lock_bh(&port->bc_queue.lock);
 330         skb_queue_splice_tail_init(&port->bc_queue, &list);
 331         spin_unlock_bh(&port->bc_queue.lock);
 332
 333         while ((skb = __skb_dequeue(&list))) {
 334                 const struct macvlan_dev *src = MACVLAN_SKB_CB(skb)->src;
 335
 336                 rcu_read_lock();
 337                 macvlan_multicast_rx(port, src, skb);
 338                 rcu_read_unlock();
 339
 340                 if (src)
 341                         dev_put(src->dev);
 342                 consume_skb(skb);
 343
 344                 cond_resched();
 345         }
 346 }
 347
 348 static void macvlan_broadcast_enqueue(struct macvlan_port *port,
 349                                       const struct macvlan_dev *src,
 350                                       struct sk_buff *skb)
 351 {
 352         struct sk_buff *nskb;
 353         int err = -ENOMEM;
 354
 355         nskb = skb_clone(skb, GFP_ATOMIC);
 356         if (!nskb)
 357                 goto err;
 358
 359         MACVLAN_SKB_CB(nskb)->src = src;
 360
 361         spin_lock(&port->bc_queue.lock);
 362         if (skb_queue_len(&port->bc_queue) < port->bc_queue_len_used) {
 363                 if (src)
 364                         dev_hold(src->dev);
 365                 __skb_queue_tail(&port->bc_queue, nskb);
 366                 err = 0;
 367         }
 368         spin_unlock(&port->bc_queue.lock);
 369
 370         queue_work(system_unbound_wq, &port->bc_work);
 371
 372         if (err)
 373                 goto free_nskb;
 374
 375         return;
 376
 377 free_nskb:
 378         kfree_skb(nskb);
 379 err:
 380         dev_core_stats_rx_dropped_inc(skb->dev);
 381 }
 382
 383 static void macvlan_flush_sources(struct macvlan_port *port,
 384                                   struct macvlan_dev *vlan)
 385 {
 386         struct macvlan_source_entry *entry;
 387         struct hlist_node *next;
 388         int i;
 389
 390         hash_for_each_safe(port->vlan_source_hash, i, next, entry, hlist)
 391                 if (entry->vlan == vlan)
 392                         macvlan_hash_del_source(entry);
 393
 394         vlan->macaddr_count = 0;
 395 }
 396
 397 static void macvlan_forward_source_one(struct sk_buff *skb,
 398                                        struct macvlan_dev *vlan)
 399 {
 400         struct sk_buff *nskb;
 401         struct net_device *dev;
 402         int len;
 403         int ret;
 404
 405         dev = vlan->dev;
 406         if (unlikely(!(dev->flags & IFF_UP)))
 407                 return;
 408
 409         nskb = skb_clone(skb, GFP_ATOMIC);
 410         if (!nskb)
 411                 return;
 412
 413         len = nskb->len + ETH_HLEN;
 414         nskb->dev = dev;
 415
 416         if (ether_addr_equal_64bits(eth_hdr(skb)->h_dest, dev->dev_addr))
 417                 nskb->pkt_type = PACKET_HOST;
 418
 419         ret = __netif_rx(nskb);
 420         macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false);
 421 }
 422
 423 static bool macvlan_forward_source(struct sk_buff *skb,
 424                                    struct macvlan_port *port,
 425                                    const unsigned char *addr)
 426 {
 427         struct macvlan_source_entry *entry;
 428         u32 idx = macvlan_eth_hash(addr);
 429         struct hlist_head *h = &port->vlan_source_hash[idx];
 430         bool consume = false;
 431
 432         hlist_for_each_entry_rcu(entry, h, hlist) {
 433                 if (ether_addr_equal_64bits(entry->addr, addr)) {
 434                         if (entry->vlan->flags & MACVLAN_FLAG_NODST)
 435                                 consume = true;
 436                         macvlan_forward_source_one(skb, entry->vlan);
 437                 }
 438         }
 439
 440         return consume;
 441 }
 442
 443 /* called under rcu_read_lock() from netif_receive_skb */
 444 static rx_handler_result_t macvlan_handle_frame(struct sk_buff **pskb)
 445 {
 446         struct macvlan_port *port;
 447         struct sk_buff *skb = *pskb;
 448         const struct ethhdr *eth = eth_hdr(skb);
 449         const struct macvlan_dev *vlan;
 450         const struct macvlan_dev *src;
 451         struct net_device *dev;
 452         unsigned int len = 0;
 453         int ret;
 454         rx_handler_result_t handle_res;
 455
 456         /* Packets from dev_loopback_xmit() do not have L2 header, bail out */
 457         if (unlikely(skb->pkt_type == PACKET_LOOPBACK))
 458                 return RX_HANDLER_PASS;
 459
 460         port = macvlan_port_get_rcu(skb->dev);
 461         if (is_multicast_ether_addr(eth->h_dest)) {
 462                 unsigned int hash;
 463
 464                 skb = ip_check_defrag(dev_net(skb->dev), skb, IP_DEFRAG_MACVLAN);
 465                 if (!skb)
 466                         return RX_HANDLER_CONSUMED;
 467                 *pskb = skb;
 468                 eth = eth_hdr(skb);
 469                 if (macvlan_forward_source(skb, port, eth->h_source)) {
 470                         kfree_skb(skb);
 471                         return RX_HANDLER_CONSUMED;
 472                 }
 473                 src = macvlan_hash_lookup(port, eth->h_source);
 474                 if (src && src->mode != MACVLAN_MODE_VEPA &&
 475                     src->mode != MACVLAN_MODE_BRIDGE) {
 476                         /* forward to original port. */
 477                         vlan = src;
 478                         ret = macvlan_broadcast_one(skb, vlan, eth, 0) ?:
 479                               __netif_rx(skb);
 480                         handle_res = RX_HANDLER_CONSUMED;
 481                         goto out;
 482                 }
 483
 484                 hash = mc_hash(NULL, eth->h_dest);
 485                 if (test_bit(hash, port->bc_filter))
 486                         macvlan_broadcast_enqueue(port, src, skb);
 487                 else if (test_bit(hash, port->mc_filter))
 488                         macvlan_multicast_rx(port, src, skb);
 489
 490                 return RX_HANDLER_PASS;
 491         }
 492
 493         if (macvlan_forward_source(skb, port, eth->h_source)) {
 494                 kfree_skb(skb);
 495                 return RX_HANDLER_CONSUMED;
 496         }
 497         if (macvlan_passthru(port))
 498                 vlan = list_first_or_null_rcu(&port->vlans,
 499                                               struct macvlan_dev, list);
 500         else
 501                 vlan = macvlan_hash_lookup(port, eth->h_dest);
 502         if (!vlan || vlan->mode == MACVLAN_MODE_SOURCE)
 503                 return RX_HANDLER_PASS;
 504
 505         dev = vlan->dev;
 506         if (unlikely(!(dev->flags & IFF_UP))) {
 507                 kfree_skb(skb);
 508                 return RX_HANDLER_CONSUMED;
 509         }
 510         len = skb->len + ETH_HLEN;
 511         skb = skb_share_check(skb, GFP_ATOMIC);
 512         if (!skb) {
 513                 ret = NET_RX_DROP;
 514                 handle_res = RX_HANDLER_CONSUMED;
 515                 goto out;
 516         }
 517
 518         *pskb = skb;
 519         skb->dev = dev;
 520         skb->pkt_type = PACKET_HOST;
 521
 522         ret = NET_RX_SUCCESS;
 523         handle_res = RX_HANDLER_ANOTHER;
 524 out:
 525         macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false);
 526         return handle_res;
 527 }
 528
 529 static int macvlan_queue_xmit(struct sk_buff *skb, struct net_device *dev)
 530 {
 531         const struct macvlan_dev *vlan = netdev_priv(dev);
 532         const struct macvlan_port *port = vlan->port;
 533         const struct macvlan_dev *dest;
 534
 535         if (vlan->mode == MACVLAN_MODE_BRIDGE) {
 536                 const struct ethhdr *eth = skb_eth_hdr(skb);
 537
 538                 /* send to other bridge ports directly */
 539                 if (is_multicast_ether_addr(eth->h_dest)) {
 540                         skb_reset_mac_header(skb);
 541                         macvlan_broadcast(skb, port, dev, MACVLAN_MODE_BRIDGE);
 542                         goto xmit_world;
 543                 }
 544
 545                 dest = macvlan_hash_lookup(port, eth->h_dest);
 546                 if (dest && dest->mode == MACVLAN_MODE_BRIDGE) {
 547                         /* send to lowerdev first for its network taps */
 548                         dev_forward_skb(vlan->lowerdev, skb);
 549
 550                         return NET_XMIT_SUCCESS;
 551                 }
 552         }
 553 xmit_world:
 554         skb->dev = vlan->lowerdev;
 555         return dev_queue_xmit_accel(skb,
 556                                     netdev_get_sb_channel(dev) ? dev : NULL);
 557 }
 558
 559 static inline netdev_tx_t macvlan_netpoll_send_skb(struct macvlan_dev *vlan, struct sk_buff *skb)
 560 {
 561 #ifdef CONFIG_NET_POLL_CONTROLLER
 562         return netpoll_send_skb(vlan->netpoll, skb);
 563 #else
 564         BUG();
 565         return NETDEV_TX_OK;
 566 #endif
 567 }
 568
 569 static netdev_tx_t macvlan_start_xmit(struct sk_buff *skb,
 570                                       struct net_device *dev)
 571 {
 572         struct macvlan_dev *vlan = netdev_priv(dev);
 573         unsigned int len = skb->len;
 574         int ret;
 575
 576         if (unlikely(netpoll_tx_running(dev)))
 577                 return macvlan_netpoll_send_skb(vlan, skb);
 578
 579         ret = macvlan_queue_xmit(skb, dev);
 580
 581         if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
 582                 struct vlan_pcpu_stats *pcpu_stats;
 583
 584                 pcpu_stats = this_cpu_ptr(vlan->pcpu_stats);
 585                 u64_stats_update_begin(&pcpu_stats->syncp);
 586                 u64_stats_inc(&pcpu_stats->tx_packets);
 587                 u64_stats_add(&pcpu_stats->tx_bytes, len);
 588                 u64_stats_update_end(&pcpu_stats->syncp);
 589         } else {
 590                 this_cpu_inc(vlan->pcpu_stats->tx_dropped);
 591         }
 592         return ret;
 593 }
 594
 595 static int macvlan_hard_header(struct sk_buff *skb, struct net_device *dev,
 596                                unsigned short type, const void *daddr,
 597                                const void *saddr, unsigned len)
 598 {
 599         const struct macvlan_dev *vlan = netdev_priv(dev);
 600         struct net_device *lowerdev = vlan->lowerdev;
 601
 602         return dev_hard_header(skb, lowerdev, type, daddr,
 603                                saddr ? : dev->dev_addr, len);
 604 }
 605
 606 static const struct header_ops macvlan_hard_header_ops = {
 607         .create         = macvlan_hard_header,
 608         .parse          = eth_header_parse,
 609         .cache          = eth_header_cache,
 610         .cache_update   = eth_header_cache_update,
 611 };
 612
 613 static int macvlan_open(struct net_device *dev)
 614 {
 615         struct macvlan_dev *vlan = netdev_priv(dev);
 616         struct net_device *lowerdev = vlan->lowerdev;
 617         int err;
 618
 619         if (macvlan_passthru(vlan->port)) {
 620                 if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC)) {
 621                         err = dev_set_promiscuity(lowerdev, 1);
 622                         if (err < 0)
 623                                 goto out;
 624                 }
 625                 goto hash_add;
 626         }
 627
 628         err = -EADDRINUSE;
 629         if (macvlan_addr_busy(vlan->port, dev->dev_addr))
 630                 goto out;
 631
 632         /* Attempt to populate accel_priv which is used to offload the L2
 633          * forwarding requests for unicast packets.
 634          */
 635         if (lowerdev->features & NETIF_F_HW_L2FW_DOFFLOAD)
 636                 vlan->accel_priv =
 637                       lowerdev->netdev_ops->ndo_dfwd_add_station(lowerdev, dev);
 638
 639         /* If earlier attempt to offload failed, or accel_priv is not
 640          * populated we must add the unicast address to the lower device.
 641          */
 642         if (IS_ERR_OR_NULL(vlan->accel_priv)) {
 643                 vlan->accel_priv = NULL;
 644                 err = dev_uc_add(lowerdev, dev->dev_addr);
 645                 if (err < 0)
 646                         goto out;
 647         }
 648
 649         if (dev->flags & IFF_ALLMULTI) {
 650                 err = dev_set_allmulti(lowerdev, 1);
 651                 if (err < 0)
 652                         goto del_unicast;
 653         }
 654
 655         if (dev->flags & IFF_PROMISC) {
 656                 err = dev_set_promiscuity(lowerdev, 1);
 657                 if (err < 0)
 658                         goto clear_multi;
 659         }
 660
 661 hash_add:
 662         macvlan_hash_add(vlan);
 663         return 0;
 664
 665 clear_multi:
 666         if (dev->flags & IFF_ALLMULTI)
 667                 dev_set_allmulti(lowerdev, -1);
 668 del_unicast:
 669         if (vlan->accel_priv) {
 670                 lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev,
 671                                                            vlan->accel_priv);
 672                 vlan->accel_priv = NULL;
 673         } else {
 674                 dev_uc_del(lowerdev, dev->dev_addr);
 675         }
 676 out:
 677         return err;
 678 }
 679
 680 static int macvlan_stop(struct net_device *dev)
 681 {
 682         struct macvlan_dev *vlan = netdev_priv(dev);
 683         struct net_device *lowerdev = vlan->lowerdev;
 684
 685         if (vlan->accel_priv) {
 686                 lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev,
 687                                                            vlan->accel_priv);
 688                 vlan->accel_priv = NULL;
 689         }
 690
 691         dev_uc_unsync(lowerdev, dev);
 692         dev_mc_unsync(lowerdev, dev);
 693
 694         if (macvlan_passthru(vlan->port)) {
 695                 if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC))
 696                         dev_set_promiscuity(lowerdev, -1);
 697                 goto hash_del;
 698         }
 699
 700         if (dev->flags & IFF_ALLMULTI)
 701                 dev_set_allmulti(lowerdev, -1);
 702
 703         if (dev->flags & IFF_PROMISC)
 704                 dev_set_promiscuity(lowerdev, -1);
 705
 706         dev_uc_del(lowerdev, dev->dev_addr);
 707
 708 hash_del:
 709         macvlan_hash_del(vlan, !dev->dismantle);
 710         return 0;
 711 }
 712
 713 static int macvlan_sync_address(struct net_device *dev,
 714                                 const unsigned char *addr)
 715 {
 716         struct macvlan_dev *vlan = netdev_priv(dev);
 717         struct net_device *lowerdev = vlan->lowerdev;
 718         struct macvlan_port *port = vlan->port;
 719         int err;
 720
 721         if (!(dev->flags & IFF_UP)) {
 722                 /* Just copy in the new address */
 723                 eth_hw_addr_set(dev, addr);
 724         } else {
 725                 /* Rehash and update the device filters */
 726                 if (macvlan_addr_busy(vlan->port, addr))
 727                         return -EADDRINUSE;
 728
 729                 if (!macvlan_passthru(port)) {
 730                         err = dev_uc_add(lowerdev, addr);
 731                         if (err)
 732                                 return err;
 733
 734                         dev_uc_del(lowerdev, dev->dev_addr);
 735                 }
 736
 737                 macvlan_hash_change_addr(vlan, addr);
 738         }
 739         if (macvlan_passthru(port) && !macvlan_addr_change(port)) {
 740                 /* Since addr_change isn't set, we are here due to lower
 741                  * device change.  Save the lower-dev address so we can
 742                  * restore it later.
 743                  */
 744                 ether_addr_copy(vlan->port->perm_addr,
 745                                 lowerdev->dev_addr);
 746         }
 747         macvlan_clear_addr_change(port);
 748         return 0;
 749 }
 750
 751 static int macvlan_set_mac_address(struct net_device *dev, void *p)
 752 {
 753         struct macvlan_dev *vlan = netdev_priv(dev);
 754         struct sockaddr *addr = p;
 755
 756         if (!is_valid_ether_addr(addr->sa_data))
 757                 return -EADDRNOTAVAIL;
 758
 759         /* If the addresses are the same, this is a no-op */
 760         if (ether_addr_equal(dev->dev_addr, addr->sa_data))
 761                 return 0;
 762
 763         if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
 764                 macvlan_set_addr_change(vlan->port);
 765                 return dev_set_mac_address(vlan->lowerdev, addr, NULL);
 766         }
 767
 768         if (macvlan_addr_busy(vlan->port, addr->sa_data))
 769                 return -EADDRINUSE;
 770
 771         return macvlan_sync_address(dev, addr->sa_data);
 772 }
 773
 774 static void macvlan_change_rx_flags(struct net_device *dev, int change)
 775 {
 776         struct macvlan_dev *vlan = netdev_priv(dev);
 777         struct net_device *lowerdev = vlan->lowerdev;
 778
 779         if (dev->flags & IFF_UP) {
 780                 if (change & IFF_ALLMULTI)
 781                         dev_set_allmulti(lowerdev, dev->flags & IFF_ALLMULTI ? 1 : -1);
 782                 if (change & IFF_PROMISC)
 783                         dev_set_promiscuity(lowerdev,
 784                                             dev->flags & IFF_PROMISC ? 1 : -1);
 785
 786         }
 787 }
 788
 789 static void macvlan_compute_filter(unsigned long *mc_filter,
 790                                    struct net_device *dev,
 791                                    struct macvlan_dev *vlan, int cutoff)
 792 {
 793         if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
 794                 if (cutoff >= 0)
 795                         bitmap_fill(mc_filter, MACVLAN_MC_FILTER_SZ);
 796                 else
 797                         bitmap_zero(mc_filter, MACVLAN_MC_FILTER_SZ);
 798         } else {
 799                 DECLARE_BITMAP(filter, MACVLAN_MC_FILTER_SZ);
 800                 struct netdev_hw_addr *ha;
 801
 802                 bitmap_zero(filter, MACVLAN_MC_FILTER_SZ);
 803                 netdev_for_each_mc_addr(ha, dev) {
 804                         if (cutoff >= 0 && ha->synced <= cutoff)
 805                                 continue;
 806
 807                         __set_bit(mc_hash(vlan, ha->addr), filter);
 808                 }
 809
 810                 if (cutoff >= 0)
 811                         __set_bit(mc_hash(vlan, dev->broadcast), filter);
 812
 813                 bitmap_copy(mc_filter, filter, MACVLAN_MC_FILTER_SZ);
 814         }
 815 }
 816
 817 static void macvlan_set_mac_lists(struct net_device *dev)
 818 {
 819         struct macvlan_dev *vlan = netdev_priv(dev);
 820
 821         macvlan_compute_filter(vlan->mc_filter, dev, vlan, 0);
 822
 823         dev_uc_sync(vlan->lowerdev, dev);
 824         dev_mc_sync(vlan->lowerdev, dev);
 825
 826         /* This is slightly inaccurate as we're including the subscription
 827          * list of vlan->lowerdev too.
 828          *
 829          * Bug alert: This only works if everyone has the same broadcast
 830          * address as lowerdev.  As soon as someone changes theirs this
 831          * will break.
 832          *
 833          * However, this is already broken as when you change your broadcast
 834          * address we don't get called.
 835          *
 836          * The solution is to maintain a list of broadcast addresses like
 837          * we do for uc/mc, if you care.
 838          */
 839         macvlan_compute_filter(vlan->port->mc_filter, vlan->lowerdev, NULL,
 840                                0);
 841         macvlan_compute_filter(vlan->port->bc_filter, vlan->lowerdev, NULL,
 842                                1);
 843 }
 844
 845 static int macvlan_change_mtu(struct net_device *dev, int new_mtu)
 846 {
 847         struct macvlan_dev *vlan = netdev_priv(dev);
 848
 849         if (vlan->lowerdev->mtu < new_mtu)
 850                 return -EINVAL;
 851         dev->mtu = new_mtu;
 852         return 0;
 853 }
 854
 855 static int macvlan_eth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 856 {
 857         struct net_device *real_dev = macvlan_dev_real_dev(dev);
 858         const struct net_device_ops *ops = real_dev->netdev_ops;
 859         struct ifreq ifrr;
 860         int err = -EOPNOTSUPP;
 861
 862         strscpy(ifrr.ifr_name, real_dev->name, IFNAMSIZ);
 863         ifrr.ifr_ifru = ifr->ifr_ifru;
 864
 865         switch (cmd) {
 866         case SIOCSHWTSTAMP:
 867                 if (!net_eq(dev_net(dev), &init_net))
 868                         break;
 869                 fallthrough;
 870         case SIOCGHWTSTAMP:
 871                 if (netif_device_present(real_dev) && ops->ndo_eth_ioctl)
 872                         err = ops->ndo_eth_ioctl(real_dev, &ifrr, cmd);
 873                 break;
 874         }
 875
 876         if (!err)
 877                 ifr->ifr_ifru = ifrr.ifr_ifru;
 878
 879         return err;
 880 }
 881
 882 /*
 883  * macvlan network devices have devices nesting below it and are a special
 884  * "super class" of normal network devices; split their locks off into a
 885  * separate class since they always nest.
 886  */
 887 static struct lock_class_key macvlan_netdev_addr_lock_key;
 888
 889 #define ALWAYS_ON_OFFLOADS \
 890         (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_GSO_SOFTWARE | \
 891          NETIF_F_GSO_ROBUST | NETIF_F_GSO_ENCAP_ALL)
 892
 893 #define ALWAYS_ON_FEATURES (ALWAYS_ON_OFFLOADS | NETIF_F_LLTX)
 894
 895 #define MACVLAN_FEATURES \
 896         (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
 897          NETIF_F_GSO | NETIF_F_TSO | NETIF_F_LRO | \
 898          NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \
 899          NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)
 900
 901 #define MACVLAN_STATE_MASK \
 902         ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT))
 903
 904 static void macvlan_set_lockdep_class(struct net_device *dev)
 905 {
 906         netdev_lockdep_set_classes(dev);
 907         lockdep_set_class(&dev->addr_list_lock,
 908                           &macvlan_netdev_addr_lock_key);
 909 }
 910
 911 static int macvlan_init(struct net_device *dev)
 912 {
 913         struct macvlan_dev *vlan = netdev_priv(dev);
 914         struct net_device *lowerdev = vlan->lowerdev;
 915         struct macvlan_port *port = vlan->port;
 916
 917         dev->state              = (dev->state & ~MACVLAN_STATE_MASK) |
 918                                   (lowerdev->state & MACVLAN_STATE_MASK);
 919         dev->features           = lowerdev->features & MACVLAN_FEATURES;
 920         dev->features           |= ALWAYS_ON_FEATURES;
 921         dev->hw_features        |= NETIF_F_LRO;
 922         dev->vlan_features      = lowerdev->vlan_features & MACVLAN_FEATURES;
 923         dev->vlan_features      |= ALWAYS_ON_OFFLOADS;
 924         dev->hw_enc_features    |= dev->features;
 925         netif_inherit_tso_max(dev, lowerdev);
 926         dev->hard_header_len    = lowerdev->hard_header_len;
 927         macvlan_set_lockdep_class(dev);
 928
 929         vlan->pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);
 930         if (!vlan->pcpu_stats)
 931                 return -ENOMEM;
 932
 933         port->count += 1;
 934
 935         /* Get macvlan's reference to lowerdev */
 936         netdev_hold(lowerdev, &vlan->dev_tracker, GFP_KERNEL);
 937
 938         return 0;
 939 }
 940
 941 static void macvlan_uninit(struct net_device *dev)
 942 {
 943         struct macvlan_dev *vlan = netdev_priv(dev);
 944         struct macvlan_port *port = vlan->port;
 945
 946         free_percpu(vlan->pcpu_stats);
 947
 948         macvlan_flush_sources(port, vlan);
 949         port->count -= 1;
 950         if (!port->count)
 951                 macvlan_port_destroy(port->dev);
 952 }
 953
 954 static void macvlan_dev_get_stats64(struct net_device *dev,
 955                                     struct rtnl_link_stats64 *stats)
 956 {
 957         struct macvlan_dev *vlan = netdev_priv(dev);
 958
 959         if (vlan->pcpu_stats) {
 960                 struct vlan_pcpu_stats *p;
 961                 u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes;
 962                 u32 rx_errors = 0, tx_dropped = 0;
 963                 unsigned int start;
 964                 int i;
 965
 966                 for_each_possible_cpu(i) {
 967                         p = per_cpu_ptr(vlan->pcpu_stats, i);
 968                         do {
 969                                 start = u64_stats_fetch_begin(&p->syncp);
 970                                 rx_packets      = u64_stats_read(&p->rx_packets);
 971                                 rx_bytes        = u64_stats_read(&p->rx_bytes);
 972                                 rx_multicast    = u64_stats_read(&p->rx_multicast);
 973                                 tx_packets      = u64_stats_read(&p->tx_packets);
 974                                 tx_bytes        = u64_stats_read(&p->tx_bytes);
 975                         } while (u64_stats_fetch_retry(&p->syncp, start));
 976
 977                         stats->rx_packets       += rx_packets;
 978                         stats->rx_bytes         += rx_bytes;
 979                         stats->multicast        += rx_multicast;
 980                         stats->tx_packets       += tx_packets;
 981                         stats->tx_bytes         += tx_bytes;
 982                         /* rx_errors & tx_dropped are u32, updated
 983                          * without syncp protection.
 984                          */
 985                         rx_errors       += READ_ONCE(p->rx_errors);
 986                         tx_dropped      += READ_ONCE(p->tx_dropped);
 987                 }
 988                 stats->rx_errors        = rx_errors;
 989                 stats->rx_dropped       = rx_errors;
 990                 stats->tx_dropped       = tx_dropped;
 991         }
 992 }
 993
 994 static int macvlan_vlan_rx_add_vid(struct net_device *dev,
 995                                    __be16 proto, u16 vid)
 996 {
 997         struct macvlan_dev *vlan = netdev_priv(dev);
 998         struct net_device *lowerdev = vlan->lowerdev;
 999
1000         return vlan_vid_add(lowerdev, proto, vid);
1001 }
1002
1003 static int macvlan_vlan_rx_kill_vid(struct net_device *dev,
1004                                     __be16 proto, u16 vid)
1005 {
1006         struct macvlan_dev *vlan = netdev_priv(dev);
1007         struct net_device *lowerdev = vlan->lowerdev;
1008
1009         vlan_vid_del(lowerdev, proto, vid);
1010         return 0;
1011 }
1012
1013 static int macvlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1014                            struct net_device *dev,
1015                            const unsigned char *addr, u16 vid,
1016                            u16 flags,
1017                            struct netlink_ext_ack *extack)
1018 {
1019         struct macvlan_dev *vlan = netdev_priv(dev);
1020         int err = -EINVAL;
1021
1022         /* Support unicast filter only on passthru devices.
1023          * Multicast filter should be allowed on all devices.
1024          */
1025         if (!macvlan_passthru(vlan->port) && is_unicast_ether_addr(addr))
1026                 return -EOPNOTSUPP;
1027
1028         if (flags & NLM_F_REPLACE)
1029                 return -EOPNOTSUPP;
1030
1031         if (is_unicast_ether_addr(addr))
1032                 err = dev_uc_add_excl(dev, addr);
1033         else if (is_multicast_ether_addr(addr))
1034                 err = dev_mc_add_excl(dev, addr);
1035
1036         return err;
1037 }
1038
1039 static int macvlan_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
1040                            struct net_device *dev,
1041                            const unsigned char *addr, u16 vid,
1042                            struct netlink_ext_ack *extack)
1043 {
1044         struct macvlan_dev *vlan = netdev_priv(dev);
1045         int err = -EINVAL;
1046
1047         /* Support unicast filter only on passthru devices.
1048          * Multicast filter should be allowed on all devices.
1049          */
1050         if (!macvlan_passthru(vlan->port) && is_unicast_ether_addr(addr))
1051                 return -EOPNOTSUPP;
1052
1053         if (is_unicast_ether_addr(addr))
1054                 err = dev_uc_del(dev, addr);
1055         else if (is_multicast_ether_addr(addr))
1056                 err = dev_mc_del(dev, addr);
1057
1058         return err;
1059 }
1060
1061 static void macvlan_ethtool_get_drvinfo(struct net_device *dev,
1062                                         struct ethtool_drvinfo *drvinfo)
1063 {
1064         strscpy(drvinfo->driver, "macvlan", sizeof(drvinfo->driver));
1065         strscpy(drvinfo->version, "0.1", sizeof(drvinfo->version));
1066 }
1067
1068 static int macvlan_ethtool_get_link_ksettings(struct net_device *dev,
1069                                               struct ethtool_link_ksettings *cmd)
1070 {
1071         const struct macvlan_dev *vlan = netdev_priv(dev);
1072
1073         return __ethtool_get_link_ksettings(vlan->lowerdev, cmd);
1074 }
1075
1076 static int macvlan_ethtool_get_ts_info(struct net_device *dev,
1077                                        struct ethtool_ts_info *info)
1078 {
1079         struct net_device *real_dev = macvlan_dev_real_dev(dev);
1080         const struct ethtool_ops *ops = real_dev->ethtool_ops;
1081         struct phy_device *phydev = real_dev->phydev;
1082
1083         if (phy_has_tsinfo(phydev)) {
1084                 return phy_ts_info(phydev, info);
1085         } else if (ops->get_ts_info) {
1086                 return ops->get_ts_info(real_dev, info);
1087         } else {
1088                 info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |
1089                         SOF_TIMESTAMPING_SOFTWARE;
1090                 info->phc_index = -1;
1091         }
1092
1093         return 0;
1094 }
1095
1096 static netdev_features_t macvlan_fix_features(struct net_device *dev,
1097                                               netdev_features_t features)
1098 {
1099         struct macvlan_dev *vlan = netdev_priv(dev);
1100         netdev_features_t lowerdev_features = vlan->lowerdev->features;
1101         netdev_features_t mask;
1102
1103         features |= NETIF_F_ALL_FOR_ALL;
1104         features &= (vlan->set_features | ~MACVLAN_FEATURES);
1105         mask = features;
1106
1107         lowerdev_features &= (features | ~NETIF_F_LRO);
1108         features = netdev_increment_features(lowerdev_features, features, mask);
1109         features |= ALWAYS_ON_FEATURES;
1110         features &= (ALWAYS_ON_FEATURES | MACVLAN_FEATURES);
1111
1112         return features;
1113 }
1114
1115 #ifdef CONFIG_NET_POLL_CONTROLLER
1116 static void macvlan_dev_poll_controller(struct net_device *dev)
1117 {
1118         return;
1119 }
1120
1121 static int macvlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo)
1122 {
1123         struct macvlan_dev *vlan = netdev_priv(dev);
1124         struct net_device *real_dev = vlan->lowerdev;
1125         struct netpoll *netpoll;
1126         int err;
1127
1128         netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
1129         err = -ENOMEM;
1130         if (!netpoll)
1131                 goto out;
1132
1133         err = __netpoll_setup(netpoll, real_dev);
1134         if (err) {
1135                 kfree(netpoll);
1136                 goto out;
1137         }
1138
1139         vlan->netpoll = netpoll;
1140
1141 out:
1142         return err;
1143 }
1144
1145 static void macvlan_dev_netpoll_cleanup(struct net_device *dev)
1146 {
1147         struct macvlan_dev *vlan = netdev_priv(dev);
1148         struct netpoll *netpoll = vlan->netpoll;
1149
1150         if (!netpoll)
1151                 return;
1152
1153         vlan->netpoll = NULL;
1154
1155         __netpoll_free(netpoll);
1156 }
1157 #endif  /* CONFIG_NET_POLL_CONTROLLER */
1158
1159 static int macvlan_dev_get_iflink(const struct net_device *dev)
1160 {
1161         struct macvlan_dev *vlan = netdev_priv(dev);
1162
1163         return vlan->lowerdev->ifindex;
1164 }
1165
1166 static const struct ethtool_ops macvlan_ethtool_ops = {
1167         .get_link               = ethtool_op_get_link,
1168         .get_link_ksettings     = macvlan_ethtool_get_link_ksettings,
1169         .get_drvinfo            = macvlan_ethtool_get_drvinfo,
1170         .get_ts_info            = macvlan_ethtool_get_ts_info,
1171 };
1172
1173 static const struct net_device_ops macvlan_netdev_ops = {
1174         .ndo_init               = macvlan_init,
1175         .ndo_uninit             = macvlan_uninit,
1176         .ndo_open               = macvlan_open,
1177         .ndo_stop               = macvlan_stop,
1178         .ndo_start_xmit         = macvlan_start_xmit,
1179         .ndo_change_mtu         = macvlan_change_mtu,
1180         .ndo_eth_ioctl          = macvlan_eth_ioctl,
1181         .ndo_fix_features       = macvlan_fix_features,
1182         .ndo_change_rx_flags    = macvlan_change_rx_flags,
1183         .ndo_set_mac_address    = macvlan_set_mac_address,
1184         .ndo_set_rx_mode        = macvlan_set_mac_lists,
1185         .ndo_get_stats64        = macvlan_dev_get_stats64,
1186         .ndo_validate_addr      = eth_validate_addr,
1187         .ndo_vlan_rx_add_vid    = macvlan_vlan_rx_add_vid,
1188         .ndo_vlan_rx_kill_vid   = macvlan_vlan_rx_kill_vid,
1189         .ndo_fdb_add            = macvlan_fdb_add,
1190         .ndo_fdb_del            = macvlan_fdb_del,
1191         .ndo_fdb_dump           = ndo_dflt_fdb_dump,
1192 #ifdef CONFIG_NET_POLL_CONTROLLER
1193         .ndo_poll_controller    = macvlan_dev_poll_controller,
1194         .ndo_netpoll_setup      = macvlan_dev_netpoll_setup,
1195         .ndo_netpoll_cleanup    = macvlan_dev_netpoll_cleanup,
1196 #endif
1197         .ndo_get_iflink         = macvlan_dev_get_iflink,
1198         .ndo_features_check     = passthru_features_check,
1199 };
1200
1201 static void macvlan_dev_free(struct net_device *dev)
1202 {
1203         struct macvlan_dev *vlan = netdev_priv(dev);
1204
1205         /* Get rid of the macvlan's reference to lowerdev */
1206         netdev_put(vlan->lowerdev, &vlan->dev_tracker);
1207 }
1208
1209 void macvlan_common_setup(struct net_device *dev)
1210 {
1211         ether_setup(dev);
1212
1213         /* ether_setup() has set dev->min_mtu to ETH_MIN_MTU. */
1214         dev->max_mtu            = ETH_MAX_MTU;
1215         dev->priv_flags        &= ~IFF_TX_SKB_SHARING;
1216         netif_keep_dst(dev);
1217         dev->priv_flags        |= IFF_UNICAST_FLT | IFF_CHANGE_PROTO_DOWN;
1218         dev->netdev_ops         = &macvlan_netdev_ops;
1219         dev->needs_free_netdev  = true;
1220         dev->priv_destructor    = macvlan_dev_free;
1221         dev->header_ops         = &macvlan_hard_header_ops;
1222         dev->ethtool_ops        = &macvlan_ethtool_ops;
1223 }
1224 EXPORT_SYMBOL_GPL(macvlan_common_setup);
1225
1226 static void macvlan_setup(struct net_device *dev)
1227 {
1228         macvlan_common_setup(dev);
1229         dev->priv_flags |= IFF_NO_QUEUE;
1230 }
1231
1232 static int macvlan_port_create(struct net_device *dev)
1233 {
1234         struct macvlan_port *port;
1235         unsigned int i;
1236         int err;
1237
1238         if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK)
1239                 return -EINVAL;
1240
1241         if (netdev_is_rx_handler_busy(dev))
1242                 return -EBUSY;
1243
1244         port = kzalloc(sizeof(*port), GFP_KERNEL);
1245         if (port == NULL)
1246                 return -ENOMEM;
1247
1248         port->dev = dev;
1249         ether_addr_copy(port->perm_addr, dev->dev_addr);
1250         INIT_LIST_HEAD(&port->vlans);
1251         for (i = 0; i < MACVLAN_HASH_SIZE; i++)
1252                 INIT_HLIST_HEAD(&port->vlan_hash[i]);
1253         for (i = 0; i < MACVLAN_HASH_SIZE; i++)
1254                 INIT_HLIST_HEAD(&port->vlan_source_hash[i]);
1255
1256         port->bc_queue_len_used = 0;
1257         skb_queue_head_init(&port->bc_queue);
1258         INIT_WORK(&port->bc_work, macvlan_process_broadcast);
1259
1260         err = netdev_rx_handler_register(dev, macvlan_handle_frame, port);
1261         if (err)
1262                 kfree(port);
1263         else
1264                 dev->priv_flags |= IFF_MACVLAN_PORT;
1265         return err;
1266 }
1267
1268 static void macvlan_port_destroy(struct net_device *dev)
1269 {
1270         struct macvlan_port *port = macvlan_port_get_rtnl(dev);
1271         struct sk_buff *skb;
1272
1273         dev->priv_flags &= ~IFF_MACVLAN_PORT;
1274         netdev_rx_handler_unregister(dev);
1275
1276         /* After this point, no packet can schedule bc_work anymore,
1277          * but we need to cancel it and purge left skbs if any.
1278          */
1279         cancel_work_sync(&port->bc_work);
1280
1281         while ((skb = __skb_dequeue(&port->bc_queue))) {
1282                 const struct macvlan_dev *src = MACVLAN_SKB_CB(skb)->src;
1283
1284                 if (src)
1285                         dev_put(src->dev);
1286
1287                 kfree_skb(skb);
1288         }
1289
1290         /* If the lower device address has been changed by passthru
1291          * macvlan, put it back.
1292          */
1293         if (macvlan_passthru(port) &&
1294             !ether_addr_equal(port->dev->dev_addr, port->perm_addr)) {
1295                 struct sockaddr sa;
1296
1297                 sa.sa_family = port->dev->type;
1298                 memcpy(&sa.sa_data, port->perm_addr, port->dev->addr_len);
1299                 dev_set_mac_address(port->dev, &sa, NULL);
1300         }
1301
1302         kfree(port);
1303 }
1304
1305 static int macvlan_validate(struct nlattr *tb[], struct nlattr *data[],
1306                             struct netlink_ext_ack *extack)
1307 {
1308         struct nlattr *nla, *head;
1309         int rem, len;
1310
1311         if (tb[IFLA_ADDRESS]) {
1312                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1313                         return -EINVAL;
1314                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1315                         return -EADDRNOTAVAIL;
1316         }
1317
1318         if (!data)
1319                 return 0;
1320
1321         if (data[IFLA_MACVLAN_FLAGS] &&
1322             nla_get_u16(data[IFLA_MACVLAN_FLAGS]) & ~(MACVLAN_FLAG_NOPROMISC |
1323                                                       MACVLAN_FLAG_NODST))
1324                 return -EINVAL;
1325
1326         if (data[IFLA_MACVLAN_MODE]) {
1327                 switch (nla_get_u32(data[IFLA_MACVLAN_MODE])) {
1328                 case MACVLAN_MODE_PRIVATE:
1329                 case MACVLAN_MODE_VEPA:
1330                 case MACVLAN_MODE_BRIDGE:
1331                 case MACVLAN_MODE_PASSTHRU:
1332                 case MACVLAN_MODE_SOURCE:
1333                         break;
1334                 default:
1335                         return -EINVAL;
1336                 }
1337         }
1338
1339         if (data[IFLA_MACVLAN_MACADDR_MODE]) {
1340                 switch (nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE])) {
1341                 case MACVLAN_MACADDR_ADD:
1342                 case MACVLAN_MACADDR_DEL:
1343                 case MACVLAN_MACADDR_FLUSH:
1344                 case MACVLAN_MACADDR_SET:
1345                         break;
1346                 default:
1347                         return -EINVAL;
1348                 }
1349         }
1350
1351         if (data[IFLA_MACVLAN_MACADDR]) {
1352                 if (nla_len(data[IFLA_MACVLAN_MACADDR]) != ETH_ALEN)
1353                         return -EINVAL;
1354
1355                 if (!is_valid_ether_addr(nla_data(data[IFLA_MACVLAN_MACADDR])))
1356                         return -EADDRNOTAVAIL;
1357         }
1358
1359         if (data[IFLA_MACVLAN_MACADDR_DATA]) {
1360                 head = nla_data(data[IFLA_MACVLAN_MACADDR_DATA]);
1361                 len = nla_len(data[IFLA_MACVLAN_MACADDR_DATA]);
1362
1363                 nla_for_each_attr(nla, head, len, rem) {
1364                         if (nla_type(nla) != IFLA_MACVLAN_MACADDR ||
1365                             nla_len(nla) != ETH_ALEN)
1366                                 return -EINVAL;
1367
1368                         if (!is_valid_ether_addr(nla_data(nla)))
1369                                 return -EADDRNOTAVAIL;
1370                 }
1371         }
1372
1373         if (data[IFLA_MACVLAN_MACADDR_COUNT])
1374                 return -EINVAL;
1375
1376         return 0;
1377 }
1378
1379 /*
1380  * reconfigure list of remote source mac address
1381  * (only for macvlan devices in source mode)
1382  * Note regarding alignment: all netlink data is aligned to 4 Byte, which
1383  * suffices for both ether_addr_copy and ether_addr_equal_64bits usage.
1384  */
1385 static int macvlan_changelink_sources(struct macvlan_dev *vlan, u32 mode,
1386                                       struct nlattr *data[])
1387 {
1388         char *addr = NULL;
1389         int ret, rem, len;
1390         struct nlattr *nla, *head;
1391         struct macvlan_source_entry *entry;
1392
1393         if (data[IFLA_MACVLAN_MACADDR])
1394                 addr = nla_data(data[IFLA_MACVLAN_MACADDR]);
1395
1396         if (mode == MACVLAN_MACADDR_ADD) {
1397                 if (!addr)
1398                         return -EINVAL;
1399
1400                 return macvlan_hash_add_source(vlan, addr);
1401
1402         } else if (mode == MACVLAN_MACADDR_DEL) {
1403                 if (!addr)
1404                         return -EINVAL;
1405
1406                 entry = macvlan_hash_lookup_source(vlan, addr);
1407                 if (entry) {
1408                         macvlan_hash_del_source(entry);
1409                         vlan->macaddr_count--;
1410                 }
1411         } else if (mode == MACVLAN_MACADDR_FLUSH) {
1412                 macvlan_flush_sources(vlan->port, vlan);
1413         } else if (mode == MACVLAN_MACADDR_SET) {
1414                 macvlan_flush_sources(vlan->port, vlan);
1415
1416                 if (addr) {
1417                         ret = macvlan_hash_add_source(vlan, addr);
1418                         if (ret)
1419                                 return ret;
1420                 }
1421
1422                 if (!data[IFLA_MACVLAN_MACADDR_DATA])
1423                         return 0;
1424
1425                 head = nla_data(data[IFLA_MACVLAN_MACADDR_DATA]);
1426                 len = nla_len(data[IFLA_MACVLAN_MACADDR_DATA]);
1427
1428                 nla_for_each_attr(nla, head, len, rem) {
1429                         addr = nla_data(nla);
1430                         ret = macvlan_hash_add_source(vlan, addr);
1431                         if (ret)
1432                                 return ret;
1433                 }
1434         } else {
1435                 return -EINVAL;
1436         }
1437
1438         return 0;
1439 }
1440
1441 int macvlan_common_newlink(struct net *src_net, struct net_device *dev,
1442                            struct nlattr *tb[], struct nlattr *data[],
1443                            struct netlink_ext_ack *extack)
1444 {
1445         struct macvlan_dev *vlan = netdev_priv(dev);
1446         struct macvlan_port *port;
1447         struct net_device *lowerdev;
1448         int err;
1449         int macmode;
1450         bool create = false;
1451
1452         if (!tb[IFLA_LINK])
1453                 return -EINVAL;
1454
1455         lowerdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
1456         if (lowerdev == NULL)
1457                 return -ENODEV;
1458
1459         /* When creating macvlans or macvtaps on top of other macvlans - use
1460          * the real device as the lowerdev.
1461          */
1462         if (netif_is_macvlan(lowerdev))
1463                 lowerdev = macvlan_dev_real_dev(lowerdev);
1464
1465         if (!tb[IFLA_MTU])
1466                 dev->mtu = lowerdev->mtu;
1467         else if (dev->mtu > lowerdev->mtu)
1468                 return -EINVAL;
1469
1470         /* MTU range: 68 - lowerdev->max_mtu */
1471         dev->min_mtu = ETH_MIN_MTU;
1472         dev->max_mtu = lowerdev->max_mtu;
1473
1474         if (!tb[IFLA_ADDRESS])
1475                 eth_hw_addr_random(dev);
1476
1477         if (!netif_is_macvlan_port(lowerdev)) {
1478                 err = macvlan_port_create(lowerdev);
1479                 if (err < 0)
1480                         return err;
1481                 create = true;
1482         }
1483         port = macvlan_port_get_rtnl(lowerdev);
1484
1485         /* Only 1 macvlan device can be created in passthru mode */
1486         if (macvlan_passthru(port)) {
1487                 /* The macvlan port must be not created this time,
1488                  * still goto destroy_macvlan_port for readability.
1489                  */
1490                 err = -EINVAL;
1491                 goto destroy_macvlan_port;
1492         }
1493
1494         vlan->lowerdev = lowerdev;
1495         vlan->dev      = dev;
1496         vlan->port     = port;
1497         vlan->set_features = MACVLAN_FEATURES;
1498
1499         vlan->mode     = MACVLAN_MODE_VEPA;
1500         if (data && data[IFLA_MACVLAN_MODE])
1501                 vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);
1502
1503         if (data && data[IFLA_MACVLAN_FLAGS])
1504                 vlan->flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);
1505
1506         if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
1507                 if (port->count) {
1508                         err = -EINVAL;
1509                         goto destroy_macvlan_port;
1510                 }
1511                 macvlan_set_passthru(port);
1512                 eth_hw_addr_inherit(dev, lowerdev);
1513         }
1514
1515         if (data && data[IFLA_MACVLAN_MACADDR_MODE]) {
1516                 if (vlan->mode != MACVLAN_MODE_SOURCE) {
1517                         err = -EINVAL;
1518                         goto destroy_macvlan_port;
1519                 }
1520                 macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]);
1521                 err = macvlan_changelink_sources(vlan, macmode, data);
1522                 if (err)
1523                         goto destroy_macvlan_port;
1524         }
1525
1526         vlan->bc_queue_len_req = MACVLAN_DEFAULT_BC_QUEUE_LEN;
1527         if (data && data[IFLA_MACVLAN_BC_QUEUE_LEN])
1528                 vlan->bc_queue_len_req = nla_get_u32(data[IFLA_MACVLAN_BC_QUEUE_LEN]);
1529
1530         err = register_netdevice(dev);
1531         if (err < 0)
1532                 goto destroy_macvlan_port;
1533
1534         dev->priv_flags |= IFF_MACVLAN;
1535         err = netdev_upper_dev_link(lowerdev, dev, extack);
1536         if (err)
1537                 goto unregister_netdev;
1538
1539         list_add_tail_rcu(&vlan->list, &port->vlans);
1540         update_port_bc_queue_len(vlan->port);
1541         netif_stacked_transfer_operstate(lowerdev, dev);
1542         linkwatch_fire_event(dev);
1543
1544         return 0;
1545
1546 unregister_netdev:
1547         /* macvlan_uninit would free the macvlan port */
1548         unregister_netdevice(dev);
1549         return err;
1550 destroy_macvlan_port:
1551         /* the macvlan port may be freed by macvlan_uninit when fail to register.
1552          * so we destroy the macvlan port only when it's valid.
1553          */
1554         if (create && macvlan_port_get_rtnl(lowerdev)) {
1555                 macvlan_flush_sources(port, vlan);
1556                 macvlan_port_destroy(port->dev);
1557         }
1558         return err;
1559 }
1560 EXPORT_SYMBOL_GPL(macvlan_common_newlink);
1561
1562 static int macvlan_newlink(struct net *src_net, struct net_device *dev,
1563                            struct nlattr *tb[], struct nlattr *data[],
1564                            struct netlink_ext_ack *extack)
1565 {
1566         return macvlan_common_newlink(src_net, dev, tb, data, extack);
1567 }
1568
1569 void macvlan_dellink(struct net_device *dev, struct list_head *head)
1570 {
1571         struct macvlan_dev *vlan = netdev_priv(dev);
1572
1573         if (vlan->mode == MACVLAN_MODE_SOURCE)
1574                 macvlan_flush_sources(vlan->port, vlan);
1575         list_del_rcu(&vlan->list);
1576         update_port_bc_queue_len(vlan->port);
1577         unregister_netdevice_queue(dev, head);
1578         netdev_upper_dev_unlink(vlan->lowerdev, dev);
1579 }
1580 EXPORT_SYMBOL_GPL(macvlan_dellink);
1581
1582 static int macvlan_changelink(struct net_device *dev,
1583                               struct nlattr *tb[], struct nlattr *data[],
1584                               struct netlink_ext_ack *extack)
1585 {
1586         struct macvlan_dev *vlan = netdev_priv(dev);
1587         enum macvlan_mode mode;
1588         bool set_mode = false;
1589         enum macvlan_macaddr_mode macmode;
1590         int ret;
1591
1592         /* Validate mode, but don't set yet: setting flags may fail. */
1593         if (data && data[IFLA_MACVLAN_MODE]) {
1594                 set_mode = true;
1595                 mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);
1596                 /* Passthrough mode can't be set or cleared dynamically */
1597                 if ((mode == MACVLAN_MODE_PASSTHRU) !=
1598                     (vlan->mode == MACVLAN_MODE_PASSTHRU))
1599                         return -EINVAL;
1600                 if (vlan->mode == MACVLAN_MODE_SOURCE &&
1601                     vlan->mode != mode)
1602                         macvlan_flush_sources(vlan->port, vlan);
1603         }
1604
1605         if (data && data[IFLA_MACVLAN_FLAGS]) {
1606                 __u16 flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);
1607                 bool promisc = (flags ^ vlan->flags) & MACVLAN_FLAG_NOPROMISC;
1608                 if (macvlan_passthru(vlan->port) && promisc) {
1609                         int err;
1610
1611                         if (flags & MACVLAN_FLAG_NOPROMISC)
1612                                 err = dev_set_promiscuity(vlan->lowerdev, -1);
1613                         else
1614                                 err = dev_set_promiscuity(vlan->lowerdev, 1);
1615                         if (err < 0)
1616                                 return err;
1617                 }
1618                 vlan->flags = flags;
1619         }
1620
1621         if (data && data[IFLA_MACVLAN_BC_QUEUE_LEN]) {
1622                 vlan->bc_queue_len_req = nla_get_u32(data[IFLA_MACVLAN_BC_QUEUE_LEN]);
1623                 update_port_bc_queue_len(vlan->port);
1624         }
1625
1626         if (set_mode)
1627                 vlan->mode = mode;
1628         if (data && data[IFLA_MACVLAN_MACADDR_MODE]) {
1629                 if (vlan->mode != MACVLAN_MODE_SOURCE)
1630                         return -EINVAL;
1631                 macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]);
1632                 ret = macvlan_changelink_sources(vlan, macmode, data);
1633                 if (ret)
1634                         return ret;
1635         }
1636         return 0;
1637 }
1638
1639 static size_t macvlan_get_size_mac(const struct macvlan_dev *vlan)
1640 {
1641         if (vlan->macaddr_count == 0)
1642                 return 0;
1643         return nla_total_size(0) /* IFLA_MACVLAN_MACADDR_DATA */
1644                 + vlan->macaddr_count * nla_total_size(sizeof(u8) * ETH_ALEN);
1645 }
1646
1647 static size_t macvlan_get_size(const struct net_device *dev)
1648 {
1649         struct macvlan_dev *vlan = netdev_priv(dev);
1650
1651         return (0
1652                 + nla_total_size(4) /* IFLA_MACVLAN_MODE */
1653                 + nla_total_size(2) /* IFLA_MACVLAN_FLAGS */
1654                 + nla_total_size(4) /* IFLA_MACVLAN_MACADDR_COUNT */
1655                 + macvlan_get_size_mac(vlan) /* IFLA_MACVLAN_MACADDR */
1656                 + nla_total_size(4) /* IFLA_MACVLAN_BC_QUEUE_LEN */
1657                 + nla_total_size(4) /* IFLA_MACVLAN_BC_QUEUE_LEN_USED */
1658                 );
1659 }
1660
1661 static int macvlan_fill_info_macaddr(struct sk_buff *skb,
1662                                      const struct macvlan_dev *vlan,
1663                                      const int i)
1664 {
1665         struct hlist_head *h = &vlan->port->vlan_source_hash[i];
1666         struct macvlan_source_entry *entry;
1667
1668         hlist_for_each_entry_rcu(entry, h, hlist, lockdep_rtnl_is_held()) {
1669                 if (entry->vlan != vlan)
1670                         continue;
1671                 if (nla_put(skb, IFLA_MACVLAN_MACADDR, ETH_ALEN, entry->addr))
1672                         return 1;
1673         }
1674         return 0;
1675 }
1676
1677 static int macvlan_fill_info(struct sk_buff *skb,
1678                                 const struct net_device *dev)
1679 {
1680         struct macvlan_dev *vlan = netdev_priv(dev);
1681         struct macvlan_port *port = vlan->port;
1682         int i;
1683         struct nlattr *nest;
1684
1685         if (nla_put_u32(skb, IFLA_MACVLAN_MODE, vlan->mode))
1686                 goto nla_put_failure;
1687         if (nla_put_u16(skb, IFLA_MACVLAN_FLAGS, vlan->flags))
1688                 goto nla_put_failure;
1689         if (nla_put_u32(skb, IFLA_MACVLAN_MACADDR_COUNT, vlan->macaddr_count))
1690                 goto nla_put_failure;
1691         if (vlan->macaddr_count > 0) {
1692                 nest = nla_nest_start_noflag(skb, IFLA_MACVLAN_MACADDR_DATA);
1693                 if (nest == NULL)
1694                         goto nla_put_failure;
1695
1696                 for (i = 0; i < MACVLAN_HASH_SIZE; i++) {
1697                         if (macvlan_fill_info_macaddr(skb, vlan, i))
1698                                 goto nla_put_failure;
1699                 }
1700                 nla_nest_end(skb, nest);
1701         }
1702         if (nla_put_u32(skb, IFLA_MACVLAN_BC_QUEUE_LEN, vlan->bc_queue_len_req))
1703                 goto nla_put_failure;
1704         if (nla_put_u32(skb, IFLA_MACVLAN_BC_QUEUE_LEN_USED, port->bc_queue_len_used))
1705                 goto nla_put_failure;
1706         return 0;
1707
1708 nla_put_failure:
1709         return -EMSGSIZE;
1710 }
1711
1712 static const struct nla_policy macvlan_policy[IFLA_MACVLAN_MAX + 1] = {
1713         [IFLA_MACVLAN_MODE]  = { .type = NLA_U32 },
1714         [IFLA_MACVLAN_FLAGS] = { .type = NLA_U16 },
1715         [IFLA_MACVLAN_MACADDR_MODE] = { .type = NLA_U32 },
1716         [IFLA_MACVLAN_MACADDR] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1717         [IFLA_MACVLAN_MACADDR_DATA] = { .type = NLA_NESTED },
1718         [IFLA_MACVLAN_MACADDR_COUNT] = { .type = NLA_U32 },
1719         [IFLA_MACVLAN_BC_QUEUE_LEN] = { .type = NLA_U32 },
1720         [IFLA_MACVLAN_BC_QUEUE_LEN_USED] = { .type = NLA_REJECT },
1721 };
1722
1723 int macvlan_link_register(struct rtnl_link_ops *ops)
1724 {
1725         /* common fields */
1726         ops->validate           = macvlan_validate;
1727         ops->maxtype            = IFLA_MACVLAN_MAX;
1728         ops->policy             = macvlan_policy;
1729         ops->changelink         = macvlan_changelink;
1730         ops->get_size           = macvlan_get_size;
1731         ops->fill_info          = macvlan_fill_info;
1732
1733         return rtnl_link_register(ops);
1734 };
1735 EXPORT_SYMBOL_GPL(macvlan_link_register);
1736
1737 static struct net *macvlan_get_link_net(const struct net_device *dev)
1738 {
1739         return dev_net(macvlan_dev_real_dev(dev));
1740 }
1741
1742 static struct rtnl_link_ops macvlan_link_ops = {
1743         .kind           = "macvlan",
1744         .setup          = macvlan_setup,
1745         .newlink        = macvlan_newlink,
1746         .dellink        = macvlan_dellink,
1747         .get_link_net   = macvlan_get_link_net,
1748         .priv_size      = sizeof(struct macvlan_dev),
1749 };
1750
1751 static void update_port_bc_queue_len(struct macvlan_port *port)
1752 {
1753         u32 max_bc_queue_len_req = 0;
1754         struct macvlan_dev *vlan;
1755
1756         list_for_each_entry(vlan, &port->vlans, list) {
1757                 if (vlan->bc_queue_len_req > max_bc_queue_len_req)
1758                         max_bc_queue_len_req = vlan->bc_queue_len_req;
1759         }
1760         port->bc_queue_len_used = max_bc_queue_len_req;
1761 }
1762
1763 static int macvlan_device_event(struct notifier_block *unused,
1764                                 unsigned long event, void *ptr)
1765 {
1766         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1767         struct macvlan_dev *vlan, *next;
1768         struct macvlan_port *port;
1769         LIST_HEAD(list_kill);
1770
1771         if (!netif_is_macvlan_port(dev))
1772                 return NOTIFY_DONE;
1773
1774         port = macvlan_port_get_rtnl(dev);
1775
1776         switch (event) {
1777         case NETDEV_UP:
1778         case NETDEV_DOWN:
1779         case NETDEV_CHANGE:
1780                 list_for_each_entry(vlan, &port->vlans, list)
1781                         netif_stacked_transfer_operstate(vlan->lowerdev,
1782                                                          vlan->dev);
1783                 break;
1784         case NETDEV_FEAT_CHANGE:
1785                 list_for_each_entry(vlan, &port->vlans, list) {
1786                         netif_inherit_tso_max(vlan->dev, dev);
1787                         netdev_update_features(vlan->dev);
1788                 }
1789                 break;
1790         case NETDEV_CHANGEMTU:
1791                 list_for_each_entry(vlan, &port->vlans, list) {
1792                         if (vlan->dev->mtu <= dev->mtu)
1793                                 continue;
1794                         dev_set_mtu(vlan->dev, dev->mtu);
1795                 }
1796                 break;
1797         case NETDEV_CHANGEADDR:
1798                 if (!macvlan_passthru(port))
1799                         return NOTIFY_DONE;
1800
1801                 vlan = list_first_entry_or_null(&port->vlans,
1802                                                 struct macvlan_dev,
1803                                                 list);
1804
1805                 if (vlan && macvlan_sync_address(vlan->dev, dev->dev_addr))
1806                         return NOTIFY_BAD;
1807
1808                 break;
1809         case NETDEV_UNREGISTER:
1810                 /* twiddle thumbs on netns device moves */
1811                 if (dev->reg_state != NETREG_UNREGISTERING)
1812                         break;
1813
1814                 list_for_each_entry_safe(vlan, next, &port->vlans, list)
1815                         vlan->dev->rtnl_link_ops->dellink(vlan->dev, &list_kill);
1816                 unregister_netdevice_many(&list_kill);
1817                 break;
1818         case NETDEV_PRE_TYPE_CHANGE:
1819                 /* Forbid underlying device to change its type. */
1820                 return NOTIFY_BAD;
1821
1822         case NETDEV_NOTIFY_PEERS:
1823         case NETDEV_BONDING_FAILOVER:
1824         case NETDEV_RESEND_IGMP:
1825                 /* Propagate to all vlans */
1826                 list_for_each_entry(vlan, &port->vlans, list)
1827                         call_netdevice_notifiers(event, vlan->dev);
1828         }
1829         return NOTIFY_DONE;
1830 }
1831
1832 static struct notifier_block macvlan_notifier_block __read_mostly = {
1833         .notifier_call  = macvlan_device_event,
1834 };
1835
1836 static int __init macvlan_init_module(void)
1837 {
1838         int err;
1839
1840         register_netdevice_notifier(&macvlan_notifier_block);
1841
1842         err = macvlan_link_register(&macvlan_link_ops);
1843         if (err < 0)
1844                 goto err1;
1845         return 0;
1846 err1:
1847         unregister_netdevice_notifier(&macvlan_notifier_block);
1848         return err;
1849 }
1850
1851 static void __exit macvlan_cleanup_module(void)
1852 {
1853         rtnl_link_unregister(&macvlan_link_ops);
1854         unregister_netdevice_notifier(&macvlan_notifier_block);
1855 }
1856
1857 module_init(macvlan_init_module);
1858 module_exit(macvlan_cleanup_module);
1859
1860 MODULE_LICENSE("GPL");
1861 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
1862 MODULE_DESCRIPTION("Driver for MAC address based VLANs");
1863 MODULE_ALIAS_RTNL_LINK("macvlan");