Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (c) 2007 Patrick McHardy <kaber@trash.net>
0004  *
0005  * The code this is based on carried the following copyright notice:
0006  * ---
0007  * (C) Copyright 2001-2006
0008  * Alex Zeffertt, Cambridge Broadband Ltd, ajz@cambridgebroadband.com
0009  * Re-worked by Ben Greear <greearb@candelatech.com>
0010  * ---
0011  */
0012 #include <linux/kernel.h>
0013 #include <linux/types.h>
0014 #include <linux/module.h>
0015 #include <linux/init.h>
0016 #include <linux/errno.h>
0017 #include <linux/slab.h>
0018 #include <linux/string.h>
0019 #include <linux/rculist.h>
0020 #include <linux/notifier.h>
0021 #include <linux/netdevice.h>
0022 #include <linux/etherdevice.h>
0023 #include <linux/net_tstamp.h>
0024 #include <linux/ethtool.h>
0025 #include <linux/if_arp.h>
0026 #include <linux/if_vlan.h>
0027 #include <linux/if_link.h>
0028 #include <linux/if_macvlan.h>
0029 #include <linux/hash.h>
0030 #include <linux/workqueue.h>
0031 #include <net/rtnetlink.h>
0032 #include <net/xfrm.h>
0033 #include <linux/netpoll.h>
0034 #include <linux/phy.h>
0035 
0036 #define MACVLAN_HASH_BITS   8
0037 #define MACVLAN_HASH_SIZE   (1<<MACVLAN_HASH_BITS)
0038 #define MACVLAN_DEFAULT_BC_QUEUE_LEN    1000
0039 
0040 #define MACVLAN_F_PASSTHRU  1
0041 #define MACVLAN_F_ADDRCHANGE    2
0042 
0043 struct macvlan_port {
0044     struct net_device   *dev;
0045     struct hlist_head   vlan_hash[MACVLAN_HASH_SIZE];
0046     struct list_head    vlans;
0047     struct sk_buff_head bc_queue;
0048     struct work_struct  bc_work;
0049     u32         bc_queue_len_used;
0050     u32         flags;
0051     int         count;
0052     struct hlist_head   vlan_source_hash[MACVLAN_HASH_SIZE];
0053     DECLARE_BITMAP(mc_filter, MACVLAN_MC_FILTER_SZ);
0054     unsigned char           perm_addr[ETH_ALEN];
0055 };
0056 
0057 struct macvlan_source_entry {
0058     struct hlist_node   hlist;
0059     struct macvlan_dev  *vlan;
0060     unsigned char       addr[6+2] __aligned(sizeof(u16));
0061     struct rcu_head     rcu;
0062 };
0063 
0064 struct macvlan_skb_cb {
0065     const struct macvlan_dev *src;
0066 };
0067 
0068 #define MACVLAN_SKB_CB(__skb) ((struct macvlan_skb_cb *)&((__skb)->cb[0]))
0069 
0070 static void macvlan_port_destroy(struct net_device *dev);
0071 static void update_port_bc_queue_len(struct macvlan_port *port);
0072 
0073 static inline bool macvlan_passthru(const struct macvlan_port *port)
0074 {
0075     return port->flags & MACVLAN_F_PASSTHRU;
0076 }
0077 
0078 static inline void macvlan_set_passthru(struct macvlan_port *port)
0079 {
0080     port->flags |= MACVLAN_F_PASSTHRU;
0081 }
0082 
0083 static inline bool macvlan_addr_change(const struct macvlan_port *port)
0084 {
0085     return port->flags & MACVLAN_F_ADDRCHANGE;
0086 }
0087 
0088 static inline void macvlan_set_addr_change(struct macvlan_port *port)
0089 {
0090     port->flags |= MACVLAN_F_ADDRCHANGE;
0091 }
0092 
0093 static inline void macvlan_clear_addr_change(struct macvlan_port *port)
0094 {
0095     port->flags &= ~MACVLAN_F_ADDRCHANGE;
0096 }
0097 
0098 /* Hash Ethernet address */
0099 static u32 macvlan_eth_hash(const unsigned char *addr)
0100 {
0101     u64 value = get_unaligned((u64 *)addr);
0102 
0103     /* only want 6 bytes */
0104 #ifdef __BIG_ENDIAN
0105     value >>= 16;
0106 #else
0107     value <<= 16;
0108 #endif
0109     return hash_64(value, MACVLAN_HASH_BITS);
0110 }
0111 
0112 static struct macvlan_port *macvlan_port_get_rcu(const struct net_device *dev)
0113 {
0114     return rcu_dereference(dev->rx_handler_data);
0115 }
0116 
0117 static struct macvlan_port *macvlan_port_get_rtnl(const struct net_device *dev)
0118 {
0119     return rtnl_dereference(dev->rx_handler_data);
0120 }
0121 
0122 static struct macvlan_dev *macvlan_hash_lookup(const struct macvlan_port *port,
0123                            const unsigned char *addr)
0124 {
0125     struct macvlan_dev *vlan;
0126     u32 idx = macvlan_eth_hash(addr);
0127 
0128     hlist_for_each_entry_rcu(vlan, &port->vlan_hash[idx], hlist,
0129                  lockdep_rtnl_is_held()) {
0130         if (ether_addr_equal_64bits(vlan->dev->dev_addr, addr))
0131             return vlan;
0132     }
0133     return NULL;
0134 }
0135 
0136 static struct macvlan_source_entry *macvlan_hash_lookup_source(
0137     const struct macvlan_dev *vlan,
0138     const unsigned char *addr)
0139 {
0140     struct macvlan_source_entry *entry;
0141     u32 idx = macvlan_eth_hash(addr);
0142     struct hlist_head *h = &vlan->port->vlan_source_hash[idx];
0143 
0144     hlist_for_each_entry_rcu(entry, h, hlist) {
0145         if (ether_addr_equal_64bits(entry->addr, addr) &&
0146             entry->vlan == vlan)
0147             return entry;
0148     }
0149     return NULL;
0150 }
0151 
0152 static int macvlan_hash_add_source(struct macvlan_dev *vlan,
0153                    const unsigned char *addr)
0154 {
0155     struct macvlan_port *port = vlan->port;
0156     struct macvlan_source_entry *entry;
0157     struct hlist_head *h;
0158 
0159     entry = macvlan_hash_lookup_source(vlan, addr);
0160     if (entry)
0161         return 0;
0162 
0163     entry = kmalloc(sizeof(*entry), GFP_KERNEL);
0164     if (!entry)
0165         return -ENOMEM;
0166 
0167     ether_addr_copy(entry->addr, addr);
0168     entry->vlan = vlan;
0169     h = &port->vlan_source_hash[macvlan_eth_hash(addr)];
0170     hlist_add_head_rcu(&entry->hlist, h);
0171     vlan->macaddr_count++;
0172 
0173     return 0;
0174 }
0175 
0176 static void macvlan_hash_add(struct macvlan_dev *vlan)
0177 {
0178     struct macvlan_port *port = vlan->port;
0179     const unsigned char *addr = vlan->dev->dev_addr;
0180     u32 idx = macvlan_eth_hash(addr);
0181 
0182     hlist_add_head_rcu(&vlan->hlist, &port->vlan_hash[idx]);
0183 }
0184 
0185 static void macvlan_hash_del_source(struct macvlan_source_entry *entry)
0186 {
0187     hlist_del_rcu(&entry->hlist);
0188     kfree_rcu(entry, rcu);
0189 }
0190 
0191 static void macvlan_hash_del(struct macvlan_dev *vlan, bool sync)
0192 {
0193     hlist_del_rcu(&vlan->hlist);
0194     if (sync)
0195         synchronize_rcu();
0196 }
0197 
0198 static void macvlan_hash_change_addr(struct macvlan_dev *vlan,
0199                     const unsigned char *addr)
0200 {
0201     macvlan_hash_del(vlan, true);
0202     /* Now that we are unhashed it is safe to change the device
0203      * address without confusing packet delivery.
0204      */
0205     eth_hw_addr_set(vlan->dev, addr);
0206     macvlan_hash_add(vlan);
0207 }
0208 
0209 static bool macvlan_addr_busy(const struct macvlan_port *port,
0210                   const unsigned char *addr)
0211 {
0212     /* Test to see if the specified address is
0213      * currently in use by the underlying device or
0214      * another macvlan.
0215      */
0216     if (!macvlan_passthru(port) && !macvlan_addr_change(port) &&
0217         ether_addr_equal_64bits(port->dev->dev_addr, addr))
0218         return true;
0219 
0220     if (macvlan_hash_lookup(port, addr))
0221         return true;
0222 
0223     return false;
0224 }
0225 
0226 
0227 static int macvlan_broadcast_one(struct sk_buff *skb,
0228                  const struct macvlan_dev *vlan,
0229                  const struct ethhdr *eth, bool local)
0230 {
0231     struct net_device *dev = vlan->dev;
0232 
0233     if (local)
0234         return __dev_forward_skb(dev, skb);
0235 
0236     skb->dev = dev;
0237     if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast))
0238         skb->pkt_type = PACKET_BROADCAST;
0239     else
0240         skb->pkt_type = PACKET_MULTICAST;
0241 
0242     return 0;
0243 }
0244 
0245 static u32 macvlan_hash_mix(const struct macvlan_dev *vlan)
0246 {
0247     return (u32)(((unsigned long)vlan) >> L1_CACHE_SHIFT);
0248 }
0249 
0250 
0251 static unsigned int mc_hash(const struct macvlan_dev *vlan,
0252                 const unsigned char *addr)
0253 {
0254     u32 val = __get_unaligned_cpu32(addr + 2);
0255 
0256     val ^= macvlan_hash_mix(vlan);
0257     return hash_32(val, MACVLAN_MC_FILTER_BITS);
0258 }
0259 
0260 static void macvlan_broadcast(struct sk_buff *skb,
0261                   const struct macvlan_port *port,
0262                   struct net_device *src,
0263                   enum macvlan_mode mode)
0264 {
0265     const struct ethhdr *eth = eth_hdr(skb);
0266     const struct macvlan_dev *vlan;
0267     struct sk_buff *nskb;
0268     unsigned int i;
0269     int err;
0270     unsigned int hash;
0271 
0272     if (skb->protocol == htons(ETH_P_PAUSE))
0273         return;
0274 
0275     hash_for_each_rcu(port->vlan_hash, i, vlan, hlist) {
0276         if (vlan->dev == src || !(vlan->mode & mode))
0277             continue;
0278 
0279         hash = mc_hash(vlan, eth->h_dest);
0280         if (!test_bit(hash, vlan->mc_filter))
0281             continue;
0282 
0283         err = NET_RX_DROP;
0284         nskb = skb_clone(skb, GFP_ATOMIC);
0285         if (likely(nskb))
0286             err = macvlan_broadcast_one(nskb, vlan, eth,
0287                     mode == MACVLAN_MODE_BRIDGE) ?:
0288                   netif_rx(nskb);
0289         macvlan_count_rx(vlan, skb->len + ETH_HLEN,
0290                  err == NET_RX_SUCCESS, true);
0291     }
0292 }
0293 
0294 static void macvlan_process_broadcast(struct work_struct *w)
0295 {
0296     struct macvlan_port *port = container_of(w, struct macvlan_port,
0297                          bc_work);
0298     struct sk_buff *skb;
0299     struct sk_buff_head list;
0300 
0301     __skb_queue_head_init(&list);
0302 
0303     spin_lock_bh(&port->bc_queue.lock);
0304     skb_queue_splice_tail_init(&port->bc_queue, &list);
0305     spin_unlock_bh(&port->bc_queue.lock);
0306 
0307     while ((skb = __skb_dequeue(&list))) {
0308         const struct macvlan_dev *src = MACVLAN_SKB_CB(skb)->src;
0309 
0310         rcu_read_lock();
0311 
0312         if (!src)
0313             /* frame comes from an external address */
0314             macvlan_broadcast(skb, port, NULL,
0315                       MACVLAN_MODE_PRIVATE |
0316                       MACVLAN_MODE_VEPA    |
0317                       MACVLAN_MODE_PASSTHRU|
0318                       MACVLAN_MODE_BRIDGE);
0319         else if (src->mode == MACVLAN_MODE_VEPA)
0320             /* flood to everyone except source */
0321             macvlan_broadcast(skb, port, src->dev,
0322                       MACVLAN_MODE_VEPA |
0323                       MACVLAN_MODE_BRIDGE);
0324         else
0325             /*
0326              * flood only to VEPA ports, bridge ports
0327              * already saw the frame on the way out.
0328              */
0329             macvlan_broadcast(skb, port, src->dev,
0330                       MACVLAN_MODE_VEPA);
0331 
0332         rcu_read_unlock();
0333 
0334         if (src)
0335             dev_put(src->dev);
0336         consume_skb(skb);
0337 
0338         cond_resched();
0339     }
0340 }
0341 
0342 static void macvlan_broadcast_enqueue(struct macvlan_port *port,
0343                       const struct macvlan_dev *src,
0344                       struct sk_buff *skb)
0345 {
0346     struct sk_buff *nskb;
0347     int err = -ENOMEM;
0348 
0349     nskb = skb_clone(skb, GFP_ATOMIC);
0350     if (!nskb)
0351         goto err;
0352 
0353     MACVLAN_SKB_CB(nskb)->src = src;
0354 
0355     spin_lock(&port->bc_queue.lock);
0356     if (skb_queue_len(&port->bc_queue) < port->bc_queue_len_used) {
0357         if (src)
0358             dev_hold(src->dev);
0359         __skb_queue_tail(&port->bc_queue, nskb);
0360         err = 0;
0361     }
0362     spin_unlock(&port->bc_queue.lock);
0363 
0364     schedule_work(&port->bc_work);
0365 
0366     if (err)
0367         goto free_nskb;
0368 
0369     return;
0370 
0371 free_nskb:
0372     kfree_skb(nskb);
0373 err:
0374     dev_core_stats_rx_dropped_inc(skb->dev);
0375 }
0376 
0377 static void macvlan_flush_sources(struct macvlan_port *port,
0378                   struct macvlan_dev *vlan)
0379 {
0380     struct macvlan_source_entry *entry;
0381     struct hlist_node *next;
0382     int i;
0383 
0384     hash_for_each_safe(port->vlan_source_hash, i, next, entry, hlist)
0385         if (entry->vlan == vlan)
0386             macvlan_hash_del_source(entry);
0387 
0388     vlan->macaddr_count = 0;
0389 }
0390 
0391 static void macvlan_forward_source_one(struct sk_buff *skb,
0392                        struct macvlan_dev *vlan)
0393 {
0394     struct sk_buff *nskb;
0395     struct net_device *dev;
0396     int len;
0397     int ret;
0398 
0399     dev = vlan->dev;
0400     if (unlikely(!(dev->flags & IFF_UP)))
0401         return;
0402 
0403     nskb = skb_clone(skb, GFP_ATOMIC);
0404     if (!nskb)
0405         return;
0406 
0407     len = nskb->len + ETH_HLEN;
0408     nskb->dev = dev;
0409 
0410     if (ether_addr_equal_64bits(eth_hdr(skb)->h_dest, dev->dev_addr))
0411         nskb->pkt_type = PACKET_HOST;
0412 
0413     ret = __netif_rx(nskb);
0414     macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false);
0415 }
0416 
0417 static bool macvlan_forward_source(struct sk_buff *skb,
0418                    struct macvlan_port *port,
0419                    const unsigned char *addr)
0420 {
0421     struct macvlan_source_entry *entry;
0422     u32 idx = macvlan_eth_hash(addr);
0423     struct hlist_head *h = &port->vlan_source_hash[idx];
0424     bool consume = false;
0425 
0426     hlist_for_each_entry_rcu(entry, h, hlist) {
0427         if (ether_addr_equal_64bits(entry->addr, addr)) {
0428             if (entry->vlan->flags & MACVLAN_FLAG_NODST)
0429                 consume = true;
0430             macvlan_forward_source_one(skb, entry->vlan);
0431         }
0432     }
0433 
0434     return consume;
0435 }
0436 
0437 /* called under rcu_read_lock() from netif_receive_skb */
0438 static rx_handler_result_t macvlan_handle_frame(struct sk_buff **pskb)
0439 {
0440     struct macvlan_port *port;
0441     struct sk_buff *skb = *pskb;
0442     const struct ethhdr *eth = eth_hdr(skb);
0443     const struct macvlan_dev *vlan;
0444     const struct macvlan_dev *src;
0445     struct net_device *dev;
0446     unsigned int len = 0;
0447     int ret;
0448     rx_handler_result_t handle_res;
0449 
0450     /* Packets from dev_loopback_xmit() do not have L2 header, bail out */
0451     if (unlikely(skb->pkt_type == PACKET_LOOPBACK))
0452         return RX_HANDLER_PASS;
0453 
0454     port = macvlan_port_get_rcu(skb->dev);
0455     if (is_multicast_ether_addr(eth->h_dest)) {
0456         unsigned int hash;
0457 
0458         skb = ip_check_defrag(dev_net(skb->dev), skb, IP_DEFRAG_MACVLAN);
0459         if (!skb)
0460             return RX_HANDLER_CONSUMED;
0461         *pskb = skb;
0462         eth = eth_hdr(skb);
0463         if (macvlan_forward_source(skb, port, eth->h_source)) {
0464             kfree_skb(skb);
0465             return RX_HANDLER_CONSUMED;
0466         }
0467         src = macvlan_hash_lookup(port, eth->h_source);
0468         if (src && src->mode != MACVLAN_MODE_VEPA &&
0469             src->mode != MACVLAN_MODE_BRIDGE) {
0470             /* forward to original port. */
0471             vlan = src;
0472             ret = macvlan_broadcast_one(skb, vlan, eth, 0) ?:
0473                   __netif_rx(skb);
0474             handle_res = RX_HANDLER_CONSUMED;
0475             goto out;
0476         }
0477 
0478         hash = mc_hash(NULL, eth->h_dest);
0479         if (test_bit(hash, port->mc_filter))
0480             macvlan_broadcast_enqueue(port, src, skb);
0481 
0482         return RX_HANDLER_PASS;
0483     }
0484 
0485     if (macvlan_forward_source(skb, port, eth->h_source)) {
0486         kfree_skb(skb);
0487         return RX_HANDLER_CONSUMED;
0488     }
0489     if (macvlan_passthru(port))
0490         vlan = list_first_or_null_rcu(&port->vlans,
0491                           struct macvlan_dev, list);
0492     else
0493         vlan = macvlan_hash_lookup(port, eth->h_dest);
0494     if (!vlan || vlan->mode == MACVLAN_MODE_SOURCE)
0495         return RX_HANDLER_PASS;
0496 
0497     dev = vlan->dev;
0498     if (unlikely(!(dev->flags & IFF_UP))) {
0499         kfree_skb(skb);
0500         return RX_HANDLER_CONSUMED;
0501     }
0502     len = skb->len + ETH_HLEN;
0503     skb = skb_share_check(skb, GFP_ATOMIC);
0504     if (!skb) {
0505         ret = NET_RX_DROP;
0506         handle_res = RX_HANDLER_CONSUMED;
0507         goto out;
0508     }
0509 
0510     *pskb = skb;
0511     skb->dev = dev;
0512     skb->pkt_type = PACKET_HOST;
0513 
0514     ret = NET_RX_SUCCESS;
0515     handle_res = RX_HANDLER_ANOTHER;
0516 out:
0517     macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false);
0518     return handle_res;
0519 }
0520 
0521 static int macvlan_queue_xmit(struct sk_buff *skb, struct net_device *dev)
0522 {
0523     const struct macvlan_dev *vlan = netdev_priv(dev);
0524     const struct macvlan_port *port = vlan->port;
0525     const struct macvlan_dev *dest;
0526 
0527     if (vlan->mode == MACVLAN_MODE_BRIDGE) {
0528         const struct ethhdr *eth = skb_eth_hdr(skb);
0529 
0530         /* send to other bridge ports directly */
0531         if (is_multicast_ether_addr(eth->h_dest)) {
0532             skb_reset_mac_header(skb);
0533             macvlan_broadcast(skb, port, dev, MACVLAN_MODE_BRIDGE);
0534             goto xmit_world;
0535         }
0536 
0537         dest = macvlan_hash_lookup(port, eth->h_dest);
0538         if (dest && dest->mode == MACVLAN_MODE_BRIDGE) {
0539             /* send to lowerdev first for its network taps */
0540             dev_forward_skb(vlan->lowerdev, skb);
0541 
0542             return NET_XMIT_SUCCESS;
0543         }
0544     }
0545 xmit_world:
0546     skb->dev = vlan->lowerdev;
0547     return dev_queue_xmit_accel(skb,
0548                     netdev_get_sb_channel(dev) ? dev : NULL);
0549 }
0550 
0551 static inline netdev_tx_t macvlan_netpoll_send_skb(struct macvlan_dev *vlan, struct sk_buff *skb)
0552 {
0553 #ifdef CONFIG_NET_POLL_CONTROLLER
0554     return netpoll_send_skb(vlan->netpoll, skb);
0555 #else
0556     BUG();
0557     return NETDEV_TX_OK;
0558 #endif
0559 }
0560 
0561 static netdev_tx_t macvlan_start_xmit(struct sk_buff *skb,
0562                       struct net_device *dev)
0563 {
0564     struct macvlan_dev *vlan = netdev_priv(dev);
0565     unsigned int len = skb->len;
0566     int ret;
0567 
0568     if (unlikely(netpoll_tx_running(dev)))
0569         return macvlan_netpoll_send_skb(vlan, skb);
0570 
0571     ret = macvlan_queue_xmit(skb, dev);
0572 
0573     if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
0574         struct vlan_pcpu_stats *pcpu_stats;
0575 
0576         pcpu_stats = this_cpu_ptr(vlan->pcpu_stats);
0577         u64_stats_update_begin(&pcpu_stats->syncp);
0578         u64_stats_inc(&pcpu_stats->tx_packets);
0579         u64_stats_add(&pcpu_stats->tx_bytes, len);
0580         u64_stats_update_end(&pcpu_stats->syncp);
0581     } else {
0582         this_cpu_inc(vlan->pcpu_stats->tx_dropped);
0583     }
0584     return ret;
0585 }
0586 
0587 static int macvlan_hard_header(struct sk_buff *skb, struct net_device *dev,
0588                    unsigned short type, const void *daddr,
0589                    const void *saddr, unsigned len)
0590 {
0591     const struct macvlan_dev *vlan = netdev_priv(dev);
0592     struct net_device *lowerdev = vlan->lowerdev;
0593 
0594     return dev_hard_header(skb, lowerdev, type, daddr,
0595                    saddr ? : dev->dev_addr, len);
0596 }
0597 
0598 static const struct header_ops macvlan_hard_header_ops = {
0599     .create     = macvlan_hard_header,
0600     .parse      = eth_header_parse,
0601     .cache      = eth_header_cache,
0602     .cache_update   = eth_header_cache_update,
0603 };
0604 
0605 static int macvlan_open(struct net_device *dev)
0606 {
0607     struct macvlan_dev *vlan = netdev_priv(dev);
0608     struct net_device *lowerdev = vlan->lowerdev;
0609     int err;
0610 
0611     if (macvlan_passthru(vlan->port)) {
0612         if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC)) {
0613             err = dev_set_promiscuity(lowerdev, 1);
0614             if (err < 0)
0615                 goto out;
0616         }
0617         goto hash_add;
0618     }
0619 
0620     err = -EADDRINUSE;
0621     if (macvlan_addr_busy(vlan->port, dev->dev_addr))
0622         goto out;
0623 
0624     /* Attempt to populate accel_priv which is used to offload the L2
0625      * forwarding requests for unicast packets.
0626      */
0627     if (lowerdev->features & NETIF_F_HW_L2FW_DOFFLOAD)
0628         vlan->accel_priv =
0629               lowerdev->netdev_ops->ndo_dfwd_add_station(lowerdev, dev);
0630 
0631     /* If earlier attempt to offload failed, or accel_priv is not
0632      * populated we must add the unicast address to the lower device.
0633      */
0634     if (IS_ERR_OR_NULL(vlan->accel_priv)) {
0635         vlan->accel_priv = NULL;
0636         err = dev_uc_add(lowerdev, dev->dev_addr);
0637         if (err < 0)
0638             goto out;
0639     }
0640 
0641     if (dev->flags & IFF_ALLMULTI) {
0642         err = dev_set_allmulti(lowerdev, 1);
0643         if (err < 0)
0644             goto del_unicast;
0645     }
0646 
0647     if (dev->flags & IFF_PROMISC) {
0648         err = dev_set_promiscuity(lowerdev, 1);
0649         if (err < 0)
0650             goto clear_multi;
0651     }
0652 
0653 hash_add:
0654     macvlan_hash_add(vlan);
0655     return 0;
0656 
0657 clear_multi:
0658     if (dev->flags & IFF_ALLMULTI)
0659         dev_set_allmulti(lowerdev, -1);
0660 del_unicast:
0661     if (vlan->accel_priv) {
0662         lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev,
0663                                vlan->accel_priv);
0664         vlan->accel_priv = NULL;
0665     } else {
0666         dev_uc_del(lowerdev, dev->dev_addr);
0667     }
0668 out:
0669     return err;
0670 }
0671 
0672 static int macvlan_stop(struct net_device *dev)
0673 {
0674     struct macvlan_dev *vlan = netdev_priv(dev);
0675     struct net_device *lowerdev = vlan->lowerdev;
0676 
0677     if (vlan->accel_priv) {
0678         lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev,
0679                                vlan->accel_priv);
0680         vlan->accel_priv = NULL;
0681     }
0682 
0683     dev_uc_unsync(lowerdev, dev);
0684     dev_mc_unsync(lowerdev, dev);
0685 
0686     if (macvlan_passthru(vlan->port)) {
0687         if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC))
0688             dev_set_promiscuity(lowerdev, -1);
0689         goto hash_del;
0690     }
0691 
0692     if (dev->flags & IFF_ALLMULTI)
0693         dev_set_allmulti(lowerdev, -1);
0694 
0695     if (dev->flags & IFF_PROMISC)
0696         dev_set_promiscuity(lowerdev, -1);
0697 
0698     dev_uc_del(lowerdev, dev->dev_addr);
0699 
0700 hash_del:
0701     macvlan_hash_del(vlan, !dev->dismantle);
0702     return 0;
0703 }
0704 
0705 static int macvlan_sync_address(struct net_device *dev,
0706                 const unsigned char *addr)
0707 {
0708     struct macvlan_dev *vlan = netdev_priv(dev);
0709     struct net_device *lowerdev = vlan->lowerdev;
0710     struct macvlan_port *port = vlan->port;
0711     int err;
0712 
0713     if (!(dev->flags & IFF_UP)) {
0714         /* Just copy in the new address */
0715         eth_hw_addr_set(dev, addr);
0716     } else {
0717         /* Rehash and update the device filters */
0718         if (macvlan_addr_busy(vlan->port, addr))
0719             return -EADDRINUSE;
0720 
0721         if (!macvlan_passthru(port)) {
0722             err = dev_uc_add(lowerdev, addr);
0723             if (err)
0724                 return err;
0725 
0726             dev_uc_del(lowerdev, dev->dev_addr);
0727         }
0728 
0729         macvlan_hash_change_addr(vlan, addr);
0730     }
0731     if (macvlan_passthru(port) && !macvlan_addr_change(port)) {
0732         /* Since addr_change isn't set, we are here due to lower
0733          * device change.  Save the lower-dev address so we can
0734          * restore it later.
0735          */
0736         ether_addr_copy(vlan->port->perm_addr,
0737                 lowerdev->dev_addr);
0738     }
0739     macvlan_clear_addr_change(port);
0740     return 0;
0741 }
0742 
0743 static int macvlan_set_mac_address(struct net_device *dev, void *p)
0744 {
0745     struct macvlan_dev *vlan = netdev_priv(dev);
0746     struct sockaddr *addr = p;
0747 
0748     if (!is_valid_ether_addr(addr->sa_data))
0749         return -EADDRNOTAVAIL;
0750 
0751     /* If the addresses are the same, this is a no-op */
0752     if (ether_addr_equal(dev->dev_addr, addr->sa_data))
0753         return 0;
0754 
0755     if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
0756         macvlan_set_addr_change(vlan->port);
0757         return dev_set_mac_address(vlan->lowerdev, addr, NULL);
0758     }
0759 
0760     if (macvlan_addr_busy(vlan->port, addr->sa_data))
0761         return -EADDRINUSE;
0762 
0763     return macvlan_sync_address(dev, addr->sa_data);
0764 }
0765 
0766 static void macvlan_change_rx_flags(struct net_device *dev, int change)
0767 {
0768     struct macvlan_dev *vlan = netdev_priv(dev);
0769     struct net_device *lowerdev = vlan->lowerdev;
0770 
0771     if (dev->flags & IFF_UP) {
0772         if (change & IFF_ALLMULTI)
0773             dev_set_allmulti(lowerdev, dev->flags & IFF_ALLMULTI ? 1 : -1);
0774         if (change & IFF_PROMISC)
0775             dev_set_promiscuity(lowerdev,
0776                         dev->flags & IFF_PROMISC ? 1 : -1);
0777 
0778     }
0779 }
0780 
0781 static void macvlan_compute_filter(unsigned long *mc_filter,
0782                    struct net_device *dev,
0783                    struct macvlan_dev *vlan)
0784 {
0785     if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
0786         bitmap_fill(mc_filter, MACVLAN_MC_FILTER_SZ);
0787     } else {
0788         struct netdev_hw_addr *ha;
0789         DECLARE_BITMAP(filter, MACVLAN_MC_FILTER_SZ);
0790 
0791         bitmap_zero(filter, MACVLAN_MC_FILTER_SZ);
0792         netdev_for_each_mc_addr(ha, dev) {
0793             __set_bit(mc_hash(vlan, ha->addr), filter);
0794         }
0795 
0796         __set_bit(mc_hash(vlan, dev->broadcast), filter);
0797 
0798         bitmap_copy(mc_filter, filter, MACVLAN_MC_FILTER_SZ);
0799     }
0800 }
0801 
0802 static void macvlan_set_mac_lists(struct net_device *dev)
0803 {
0804     struct macvlan_dev *vlan = netdev_priv(dev);
0805 
0806     macvlan_compute_filter(vlan->mc_filter, dev, vlan);
0807 
0808     dev_uc_sync(vlan->lowerdev, dev);
0809     dev_mc_sync(vlan->lowerdev, dev);
0810 
0811     /* This is slightly inaccurate as we're including the subscription
0812      * list of vlan->lowerdev too.
0813      *
0814      * Bug alert: This only works if everyone has the same broadcast
0815      * address as lowerdev.  As soon as someone changes theirs this
0816      * will break.
0817      *
0818      * However, this is already broken as when you change your broadcast
0819      * address we don't get called.
0820      *
0821      * The solution is to maintain a list of broadcast addresses like
0822      * we do for uc/mc, if you care.
0823      */
0824     macvlan_compute_filter(vlan->port->mc_filter, vlan->lowerdev, NULL);
0825 }
0826 
0827 static int macvlan_change_mtu(struct net_device *dev, int new_mtu)
0828 {
0829     struct macvlan_dev *vlan = netdev_priv(dev);
0830 
0831     if (vlan->lowerdev->mtu < new_mtu)
0832         return -EINVAL;
0833     dev->mtu = new_mtu;
0834     return 0;
0835 }
0836 
0837 static int macvlan_eth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
0838 {
0839     struct net_device *real_dev = macvlan_dev_real_dev(dev);
0840     const struct net_device_ops *ops = real_dev->netdev_ops;
0841     struct ifreq ifrr;
0842     int err = -EOPNOTSUPP;
0843 
0844     strscpy(ifrr.ifr_name, real_dev->name, IFNAMSIZ);
0845     ifrr.ifr_ifru = ifr->ifr_ifru;
0846 
0847     switch (cmd) {
0848     case SIOCSHWTSTAMP:
0849         if (!net_eq(dev_net(dev), &init_net))
0850             break;
0851         fallthrough;
0852     case SIOCGHWTSTAMP:
0853         if (netif_device_present(real_dev) && ops->ndo_eth_ioctl)
0854             err = ops->ndo_eth_ioctl(real_dev, &ifrr, cmd);
0855         break;
0856     }
0857 
0858     if (!err)
0859         ifr->ifr_ifru = ifrr.ifr_ifru;
0860 
0861     return err;
0862 }
0863 
0864 /*
0865  * macvlan network devices have devices nesting below it and are a special
0866  * "super class" of normal network devices; split their locks off into a
0867  * separate class since they always nest.
0868  */
0869 static struct lock_class_key macvlan_netdev_addr_lock_key;
0870 
0871 #define ALWAYS_ON_OFFLOADS \
0872     (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_GSO_SOFTWARE | \
0873      NETIF_F_GSO_ROBUST | NETIF_F_GSO_ENCAP_ALL)
0874 
0875 #define ALWAYS_ON_FEATURES (ALWAYS_ON_OFFLOADS | NETIF_F_LLTX)
0876 
0877 #define MACVLAN_FEATURES \
0878     (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
0879      NETIF_F_GSO | NETIF_F_TSO | NETIF_F_LRO | \
0880      NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \
0881      NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)
0882 
0883 #define MACVLAN_STATE_MASK \
0884     ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT))
0885 
0886 static void macvlan_set_lockdep_class(struct net_device *dev)
0887 {
0888     netdev_lockdep_set_classes(dev);
0889     lockdep_set_class(&dev->addr_list_lock,
0890               &macvlan_netdev_addr_lock_key);
0891 }
0892 
0893 static int macvlan_init(struct net_device *dev)
0894 {
0895     struct macvlan_dev *vlan = netdev_priv(dev);
0896     struct net_device *lowerdev = vlan->lowerdev;
0897     struct macvlan_port *port = vlan->port;
0898 
0899     dev->state      = (dev->state & ~MACVLAN_STATE_MASK) |
0900                   (lowerdev->state & MACVLAN_STATE_MASK);
0901     dev->features       = lowerdev->features & MACVLAN_FEATURES;
0902     dev->features       |= ALWAYS_ON_FEATURES;
0903     dev->hw_features    |= NETIF_F_LRO;
0904     dev->vlan_features  = lowerdev->vlan_features & MACVLAN_FEATURES;
0905     dev->vlan_features  |= ALWAYS_ON_OFFLOADS;
0906     dev->hw_enc_features    |= dev->features;
0907     netif_inherit_tso_max(dev, lowerdev);
0908     dev->hard_header_len    = lowerdev->hard_header_len;
0909     macvlan_set_lockdep_class(dev);
0910 
0911     vlan->pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);
0912     if (!vlan->pcpu_stats)
0913         return -ENOMEM;
0914 
0915     port->count += 1;
0916 
0917     /* Get macvlan's reference to lowerdev */
0918     netdev_hold(lowerdev, &vlan->dev_tracker, GFP_KERNEL);
0919 
0920     return 0;
0921 }
0922 
0923 static void macvlan_uninit(struct net_device *dev)
0924 {
0925     struct macvlan_dev *vlan = netdev_priv(dev);
0926     struct macvlan_port *port = vlan->port;
0927 
0928     free_percpu(vlan->pcpu_stats);
0929 
0930     macvlan_flush_sources(port, vlan);
0931     port->count -= 1;
0932     if (!port->count)
0933         macvlan_port_destroy(port->dev);
0934 }
0935 
0936 static void macvlan_dev_get_stats64(struct net_device *dev,
0937                     struct rtnl_link_stats64 *stats)
0938 {
0939     struct macvlan_dev *vlan = netdev_priv(dev);
0940 
0941     if (vlan->pcpu_stats) {
0942         struct vlan_pcpu_stats *p;
0943         u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes;
0944         u32 rx_errors = 0, tx_dropped = 0;
0945         unsigned int start;
0946         int i;
0947 
0948         for_each_possible_cpu(i) {
0949             p = per_cpu_ptr(vlan->pcpu_stats, i);
0950             do {
0951                 start = u64_stats_fetch_begin_irq(&p->syncp);
0952                 rx_packets  = u64_stats_read(&p->rx_packets);
0953                 rx_bytes    = u64_stats_read(&p->rx_bytes);
0954                 rx_multicast    = u64_stats_read(&p->rx_multicast);
0955                 tx_packets  = u64_stats_read(&p->tx_packets);
0956                 tx_bytes    = u64_stats_read(&p->tx_bytes);
0957             } while (u64_stats_fetch_retry_irq(&p->syncp, start));
0958 
0959             stats->rx_packets   += rx_packets;
0960             stats->rx_bytes     += rx_bytes;
0961             stats->multicast    += rx_multicast;
0962             stats->tx_packets   += tx_packets;
0963             stats->tx_bytes     += tx_bytes;
0964             /* rx_errors & tx_dropped are u32, updated
0965              * without syncp protection.
0966              */
0967             rx_errors   += READ_ONCE(p->rx_errors);
0968             tx_dropped  += READ_ONCE(p->tx_dropped);
0969         }
0970         stats->rx_errors    = rx_errors;
0971         stats->rx_dropped   = rx_errors;
0972         stats->tx_dropped   = tx_dropped;
0973     }
0974 }
0975 
0976 static int macvlan_vlan_rx_add_vid(struct net_device *dev,
0977                    __be16 proto, u16 vid)
0978 {
0979     struct macvlan_dev *vlan = netdev_priv(dev);
0980     struct net_device *lowerdev = vlan->lowerdev;
0981 
0982     return vlan_vid_add(lowerdev, proto, vid);
0983 }
0984 
0985 static int macvlan_vlan_rx_kill_vid(struct net_device *dev,
0986                     __be16 proto, u16 vid)
0987 {
0988     struct macvlan_dev *vlan = netdev_priv(dev);
0989     struct net_device *lowerdev = vlan->lowerdev;
0990 
0991     vlan_vid_del(lowerdev, proto, vid);
0992     return 0;
0993 }
0994 
0995 static int macvlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
0996                struct net_device *dev,
0997                const unsigned char *addr, u16 vid,
0998                u16 flags,
0999                struct netlink_ext_ack *extack)
1000 {
1001     struct macvlan_dev *vlan = netdev_priv(dev);
1002     int err = -EINVAL;
1003 
1004     /* Support unicast filter only on passthru devices.
1005      * Multicast filter should be allowed on all devices.
1006      */
1007     if (!macvlan_passthru(vlan->port) && is_unicast_ether_addr(addr))
1008         return -EOPNOTSUPP;
1009 
1010     if (flags & NLM_F_REPLACE)
1011         return -EOPNOTSUPP;
1012 
1013     if (is_unicast_ether_addr(addr))
1014         err = dev_uc_add_excl(dev, addr);
1015     else if (is_multicast_ether_addr(addr))
1016         err = dev_mc_add_excl(dev, addr);
1017 
1018     return err;
1019 }
1020 
1021 static int macvlan_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
1022                struct net_device *dev,
1023                const unsigned char *addr, u16 vid,
1024                struct netlink_ext_ack *extack)
1025 {
1026     struct macvlan_dev *vlan = netdev_priv(dev);
1027     int err = -EINVAL;
1028 
1029     /* Support unicast filter only on passthru devices.
1030      * Multicast filter should be allowed on all devices.
1031      */
1032     if (!macvlan_passthru(vlan->port) && is_unicast_ether_addr(addr))
1033         return -EOPNOTSUPP;
1034 
1035     if (is_unicast_ether_addr(addr))
1036         err = dev_uc_del(dev, addr);
1037     else if (is_multicast_ether_addr(addr))
1038         err = dev_mc_del(dev, addr);
1039 
1040     return err;
1041 }
1042 
1043 static void macvlan_ethtool_get_drvinfo(struct net_device *dev,
1044                     struct ethtool_drvinfo *drvinfo)
1045 {
1046     strlcpy(drvinfo->driver, "macvlan", sizeof(drvinfo->driver));
1047     strlcpy(drvinfo->version, "0.1", sizeof(drvinfo->version));
1048 }
1049 
1050 static int macvlan_ethtool_get_link_ksettings(struct net_device *dev,
1051                           struct ethtool_link_ksettings *cmd)
1052 {
1053     const struct macvlan_dev *vlan = netdev_priv(dev);
1054 
1055     return __ethtool_get_link_ksettings(vlan->lowerdev, cmd);
1056 }
1057 
1058 static int macvlan_ethtool_get_ts_info(struct net_device *dev,
1059                        struct ethtool_ts_info *info)
1060 {
1061     struct net_device *real_dev = macvlan_dev_real_dev(dev);
1062     const struct ethtool_ops *ops = real_dev->ethtool_ops;
1063     struct phy_device *phydev = real_dev->phydev;
1064 
1065     if (phy_has_tsinfo(phydev)) {
1066         return phy_ts_info(phydev, info);
1067     } else if (ops->get_ts_info) {
1068         return ops->get_ts_info(real_dev, info);
1069     } else {
1070         info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |
1071             SOF_TIMESTAMPING_SOFTWARE;
1072         info->phc_index = -1;
1073     }
1074 
1075     return 0;
1076 }
1077 
1078 static netdev_features_t macvlan_fix_features(struct net_device *dev,
1079                           netdev_features_t features)
1080 {
1081     struct macvlan_dev *vlan = netdev_priv(dev);
1082     netdev_features_t lowerdev_features = vlan->lowerdev->features;
1083     netdev_features_t mask;
1084 
1085     features |= NETIF_F_ALL_FOR_ALL;
1086     features &= (vlan->set_features | ~MACVLAN_FEATURES);
1087     mask = features;
1088 
1089     lowerdev_features &= (features | ~NETIF_F_LRO);
1090     features = netdev_increment_features(lowerdev_features, features, mask);
1091     features |= ALWAYS_ON_FEATURES;
1092     features &= (ALWAYS_ON_FEATURES | MACVLAN_FEATURES);
1093 
1094     return features;
1095 }
1096 
1097 #ifdef CONFIG_NET_POLL_CONTROLLER
1098 static void macvlan_dev_poll_controller(struct net_device *dev)
1099 {
1100     return;
1101 }
1102 
1103 static int macvlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo)
1104 {
1105     struct macvlan_dev *vlan = netdev_priv(dev);
1106     struct net_device *real_dev = vlan->lowerdev;
1107     struct netpoll *netpoll;
1108     int err;
1109 
1110     netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
1111     err = -ENOMEM;
1112     if (!netpoll)
1113         goto out;
1114 
1115     err = __netpoll_setup(netpoll, real_dev);
1116     if (err) {
1117         kfree(netpoll);
1118         goto out;
1119     }
1120 
1121     vlan->netpoll = netpoll;
1122 
1123 out:
1124     return err;
1125 }
1126 
1127 static void macvlan_dev_netpoll_cleanup(struct net_device *dev)
1128 {
1129     struct macvlan_dev *vlan = netdev_priv(dev);
1130     struct netpoll *netpoll = vlan->netpoll;
1131 
1132     if (!netpoll)
1133         return;
1134 
1135     vlan->netpoll = NULL;
1136 
1137     __netpoll_free(netpoll);
1138 }
1139 #endif  /* CONFIG_NET_POLL_CONTROLLER */
1140 
1141 static int macvlan_dev_get_iflink(const struct net_device *dev)
1142 {
1143     struct macvlan_dev *vlan = netdev_priv(dev);
1144 
1145     return vlan->lowerdev->ifindex;
1146 }
1147 
1148 static const struct ethtool_ops macvlan_ethtool_ops = {
1149     .get_link       = ethtool_op_get_link,
1150     .get_link_ksettings = macvlan_ethtool_get_link_ksettings,
1151     .get_drvinfo        = macvlan_ethtool_get_drvinfo,
1152     .get_ts_info        = macvlan_ethtool_get_ts_info,
1153 };
1154 
1155 static const struct net_device_ops macvlan_netdev_ops = {
1156     .ndo_init       = macvlan_init,
1157     .ndo_uninit     = macvlan_uninit,
1158     .ndo_open       = macvlan_open,
1159     .ndo_stop       = macvlan_stop,
1160     .ndo_start_xmit     = macvlan_start_xmit,
1161     .ndo_change_mtu     = macvlan_change_mtu,
1162     .ndo_eth_ioctl      = macvlan_eth_ioctl,
1163     .ndo_fix_features   = macvlan_fix_features,
1164     .ndo_change_rx_flags    = macvlan_change_rx_flags,
1165     .ndo_set_mac_address    = macvlan_set_mac_address,
1166     .ndo_set_rx_mode    = macvlan_set_mac_lists,
1167     .ndo_get_stats64    = macvlan_dev_get_stats64,
1168     .ndo_validate_addr  = eth_validate_addr,
1169     .ndo_vlan_rx_add_vid    = macvlan_vlan_rx_add_vid,
1170     .ndo_vlan_rx_kill_vid   = macvlan_vlan_rx_kill_vid,
1171     .ndo_fdb_add        = macvlan_fdb_add,
1172     .ndo_fdb_del        = macvlan_fdb_del,
1173     .ndo_fdb_dump       = ndo_dflt_fdb_dump,
1174 #ifdef CONFIG_NET_POLL_CONTROLLER
1175     .ndo_poll_controller    = macvlan_dev_poll_controller,
1176     .ndo_netpoll_setup  = macvlan_dev_netpoll_setup,
1177     .ndo_netpoll_cleanup    = macvlan_dev_netpoll_cleanup,
1178 #endif
1179     .ndo_get_iflink     = macvlan_dev_get_iflink,
1180     .ndo_features_check = passthru_features_check,
1181 };
1182 
1183 static void macvlan_dev_free(struct net_device *dev)
1184 {
1185     struct macvlan_dev *vlan = netdev_priv(dev);
1186 
1187     /* Get rid of the macvlan's reference to lowerdev */
1188     netdev_put(vlan->lowerdev, &vlan->dev_tracker);
1189 }
1190 
1191 void macvlan_common_setup(struct net_device *dev)
1192 {
1193     ether_setup(dev);
1194 
1195     dev->min_mtu        = 0;
1196     dev->max_mtu        = ETH_MAX_MTU;
1197     dev->priv_flags        &= ~IFF_TX_SKB_SHARING;
1198     netif_keep_dst(dev);
1199     dev->priv_flags        |= IFF_UNICAST_FLT | IFF_CHANGE_PROTO_DOWN;
1200     dev->netdev_ops     = &macvlan_netdev_ops;
1201     dev->needs_free_netdev  = true;
1202     dev->priv_destructor    = macvlan_dev_free;
1203     dev->header_ops     = &macvlan_hard_header_ops;
1204     dev->ethtool_ops    = &macvlan_ethtool_ops;
1205 }
1206 EXPORT_SYMBOL_GPL(macvlan_common_setup);
1207 
1208 static void macvlan_setup(struct net_device *dev)
1209 {
1210     macvlan_common_setup(dev);
1211     dev->priv_flags |= IFF_NO_QUEUE;
1212 }
1213 
1214 static int macvlan_port_create(struct net_device *dev)
1215 {
1216     struct macvlan_port *port;
1217     unsigned int i;
1218     int err;
1219 
1220     if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK)
1221         return -EINVAL;
1222 
1223     if (netdev_is_rx_handler_busy(dev))
1224         return -EBUSY;
1225 
1226     port = kzalloc(sizeof(*port), GFP_KERNEL);
1227     if (port == NULL)
1228         return -ENOMEM;
1229 
1230     port->dev = dev;
1231     ether_addr_copy(port->perm_addr, dev->dev_addr);
1232     INIT_LIST_HEAD(&port->vlans);
1233     for (i = 0; i < MACVLAN_HASH_SIZE; i++)
1234         INIT_HLIST_HEAD(&port->vlan_hash[i]);
1235     for (i = 0; i < MACVLAN_HASH_SIZE; i++)
1236         INIT_HLIST_HEAD(&port->vlan_source_hash[i]);
1237 
1238     port->bc_queue_len_used = 0;
1239     skb_queue_head_init(&port->bc_queue);
1240     INIT_WORK(&port->bc_work, macvlan_process_broadcast);
1241 
1242     err = netdev_rx_handler_register(dev, macvlan_handle_frame, port);
1243     if (err)
1244         kfree(port);
1245     else
1246         dev->priv_flags |= IFF_MACVLAN_PORT;
1247     return err;
1248 }
1249 
1250 static void macvlan_port_destroy(struct net_device *dev)
1251 {
1252     struct macvlan_port *port = macvlan_port_get_rtnl(dev);
1253     struct sk_buff *skb;
1254 
1255     dev->priv_flags &= ~IFF_MACVLAN_PORT;
1256     netdev_rx_handler_unregister(dev);
1257 
1258     /* After this point, no packet can schedule bc_work anymore,
1259      * but we need to cancel it and purge left skbs if any.
1260      */
1261     cancel_work_sync(&port->bc_work);
1262 
1263     while ((skb = __skb_dequeue(&port->bc_queue))) {
1264         const struct macvlan_dev *src = MACVLAN_SKB_CB(skb)->src;
1265 
1266         if (src)
1267             dev_put(src->dev);
1268 
1269         kfree_skb(skb);
1270     }
1271 
1272     /* If the lower device address has been changed by passthru
1273      * macvlan, put it back.
1274      */
1275     if (macvlan_passthru(port) &&
1276         !ether_addr_equal(port->dev->dev_addr, port->perm_addr)) {
1277         struct sockaddr sa;
1278 
1279         sa.sa_family = port->dev->type;
1280         memcpy(&sa.sa_data, port->perm_addr, port->dev->addr_len);
1281         dev_set_mac_address(port->dev, &sa, NULL);
1282     }
1283 
1284     kfree(port);
1285 }
1286 
1287 static int macvlan_validate(struct nlattr *tb[], struct nlattr *data[],
1288                 struct netlink_ext_ack *extack)
1289 {
1290     struct nlattr *nla, *head;
1291     int rem, len;
1292 
1293     if (tb[IFLA_ADDRESS]) {
1294         if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1295             return -EINVAL;
1296         if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1297             return -EADDRNOTAVAIL;
1298     }
1299 
1300     if (!data)
1301         return 0;
1302 
1303     if (data[IFLA_MACVLAN_FLAGS] &&
1304         nla_get_u16(data[IFLA_MACVLAN_FLAGS]) & ~(MACVLAN_FLAG_NOPROMISC |
1305                               MACVLAN_FLAG_NODST))
1306         return -EINVAL;
1307 
1308     if (data[IFLA_MACVLAN_MODE]) {
1309         switch (nla_get_u32(data[IFLA_MACVLAN_MODE])) {
1310         case MACVLAN_MODE_PRIVATE:
1311         case MACVLAN_MODE_VEPA:
1312         case MACVLAN_MODE_BRIDGE:
1313         case MACVLAN_MODE_PASSTHRU:
1314         case MACVLAN_MODE_SOURCE:
1315             break;
1316         default:
1317             return -EINVAL;
1318         }
1319     }
1320 
1321     if (data[IFLA_MACVLAN_MACADDR_MODE]) {
1322         switch (nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE])) {
1323         case MACVLAN_MACADDR_ADD:
1324         case MACVLAN_MACADDR_DEL:
1325         case MACVLAN_MACADDR_FLUSH:
1326         case MACVLAN_MACADDR_SET:
1327             break;
1328         default:
1329             return -EINVAL;
1330         }
1331     }
1332 
1333     if (data[IFLA_MACVLAN_MACADDR]) {
1334         if (nla_len(data[IFLA_MACVLAN_MACADDR]) != ETH_ALEN)
1335             return -EINVAL;
1336 
1337         if (!is_valid_ether_addr(nla_data(data[IFLA_MACVLAN_MACADDR])))
1338             return -EADDRNOTAVAIL;
1339     }
1340 
1341     if (data[IFLA_MACVLAN_MACADDR_DATA]) {
1342         head = nla_data(data[IFLA_MACVLAN_MACADDR_DATA]);
1343         len = nla_len(data[IFLA_MACVLAN_MACADDR_DATA]);
1344 
1345         nla_for_each_attr(nla, head, len, rem) {
1346             if (nla_type(nla) != IFLA_MACVLAN_MACADDR ||
1347                 nla_len(nla) != ETH_ALEN)
1348                 return -EINVAL;
1349 
1350             if (!is_valid_ether_addr(nla_data(nla)))
1351                 return -EADDRNOTAVAIL;
1352         }
1353     }
1354 
1355     if (data[IFLA_MACVLAN_MACADDR_COUNT])
1356         return -EINVAL;
1357 
1358     return 0;
1359 }
1360 
1361 /*
1362  * reconfigure list of remote source mac address
1363  * (only for macvlan devices in source mode)
1364  * Note regarding alignment: all netlink data is aligned to 4 Byte, which
1365  * suffices for both ether_addr_copy and ether_addr_equal_64bits usage.
1366  */
1367 static int macvlan_changelink_sources(struct macvlan_dev *vlan, u32 mode,
1368                       struct nlattr *data[])
1369 {
1370     char *addr = NULL;
1371     int ret, rem, len;
1372     struct nlattr *nla, *head;
1373     struct macvlan_source_entry *entry;
1374 
1375     if (data[IFLA_MACVLAN_MACADDR])
1376         addr = nla_data(data[IFLA_MACVLAN_MACADDR]);
1377 
1378     if (mode == MACVLAN_MACADDR_ADD) {
1379         if (!addr)
1380             return -EINVAL;
1381 
1382         return macvlan_hash_add_source(vlan, addr);
1383 
1384     } else if (mode == MACVLAN_MACADDR_DEL) {
1385         if (!addr)
1386             return -EINVAL;
1387 
1388         entry = macvlan_hash_lookup_source(vlan, addr);
1389         if (entry) {
1390             macvlan_hash_del_source(entry);
1391             vlan->macaddr_count--;
1392         }
1393     } else if (mode == MACVLAN_MACADDR_FLUSH) {
1394         macvlan_flush_sources(vlan->port, vlan);
1395     } else if (mode == MACVLAN_MACADDR_SET) {
1396         macvlan_flush_sources(vlan->port, vlan);
1397 
1398         if (addr) {
1399             ret = macvlan_hash_add_source(vlan, addr);
1400             if (ret)
1401                 return ret;
1402         }
1403 
1404         if (!data[IFLA_MACVLAN_MACADDR_DATA])
1405             return 0;
1406 
1407         head = nla_data(data[IFLA_MACVLAN_MACADDR_DATA]);
1408         len = nla_len(data[IFLA_MACVLAN_MACADDR_DATA]);
1409 
1410         nla_for_each_attr(nla, head, len, rem) {
1411             addr = nla_data(nla);
1412             ret = macvlan_hash_add_source(vlan, addr);
1413             if (ret)
1414                 return ret;
1415         }
1416     } else {
1417         return -EINVAL;
1418     }
1419 
1420     return 0;
1421 }
1422 
1423 int macvlan_common_newlink(struct net *src_net, struct net_device *dev,
1424                struct nlattr *tb[], struct nlattr *data[],
1425                struct netlink_ext_ack *extack)
1426 {
1427     struct macvlan_dev *vlan = netdev_priv(dev);
1428     struct macvlan_port *port;
1429     struct net_device *lowerdev;
1430     int err;
1431     int macmode;
1432     bool create = false;
1433 
1434     if (!tb[IFLA_LINK])
1435         return -EINVAL;
1436 
1437     lowerdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
1438     if (lowerdev == NULL)
1439         return -ENODEV;
1440 
1441     /* When creating macvlans or macvtaps on top of other macvlans - use
1442      * the real device as the lowerdev.
1443      */
1444     if (netif_is_macvlan(lowerdev))
1445         lowerdev = macvlan_dev_real_dev(lowerdev);
1446 
1447     if (!tb[IFLA_MTU])
1448         dev->mtu = lowerdev->mtu;
1449     else if (dev->mtu > lowerdev->mtu)
1450         return -EINVAL;
1451 
1452     /* MTU range: 68 - lowerdev->max_mtu */
1453     dev->min_mtu = ETH_MIN_MTU;
1454     dev->max_mtu = lowerdev->max_mtu;
1455 
1456     if (!tb[IFLA_ADDRESS])
1457         eth_hw_addr_random(dev);
1458 
1459     if (!netif_is_macvlan_port(lowerdev)) {
1460         err = macvlan_port_create(lowerdev);
1461         if (err < 0)
1462             return err;
1463         create = true;
1464     }
1465     port = macvlan_port_get_rtnl(lowerdev);
1466 
1467     /* Only 1 macvlan device can be created in passthru mode */
1468     if (macvlan_passthru(port)) {
1469         /* The macvlan port must be not created this time,
1470          * still goto destroy_macvlan_port for readability.
1471          */
1472         err = -EINVAL;
1473         goto destroy_macvlan_port;
1474     }
1475 
1476     vlan->lowerdev = lowerdev;
1477     vlan->dev      = dev;
1478     vlan->port     = port;
1479     vlan->set_features = MACVLAN_FEATURES;
1480 
1481     vlan->mode     = MACVLAN_MODE_VEPA;
1482     if (data && data[IFLA_MACVLAN_MODE])
1483         vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);
1484 
1485     if (data && data[IFLA_MACVLAN_FLAGS])
1486         vlan->flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);
1487 
1488     if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
1489         if (port->count) {
1490             err = -EINVAL;
1491             goto destroy_macvlan_port;
1492         }
1493         macvlan_set_passthru(port);
1494         eth_hw_addr_inherit(dev, lowerdev);
1495     }
1496 
1497     if (data && data[IFLA_MACVLAN_MACADDR_MODE]) {
1498         if (vlan->mode != MACVLAN_MODE_SOURCE) {
1499             err = -EINVAL;
1500             goto destroy_macvlan_port;
1501         }
1502         macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]);
1503         err = macvlan_changelink_sources(vlan, macmode, data);
1504         if (err)
1505             goto destroy_macvlan_port;
1506     }
1507 
1508     vlan->bc_queue_len_req = MACVLAN_DEFAULT_BC_QUEUE_LEN;
1509     if (data && data[IFLA_MACVLAN_BC_QUEUE_LEN])
1510         vlan->bc_queue_len_req = nla_get_u32(data[IFLA_MACVLAN_BC_QUEUE_LEN]);
1511 
1512     err = register_netdevice(dev);
1513     if (err < 0)
1514         goto destroy_macvlan_port;
1515 
1516     dev->priv_flags |= IFF_MACVLAN;
1517     err = netdev_upper_dev_link(lowerdev, dev, extack);
1518     if (err)
1519         goto unregister_netdev;
1520 
1521     list_add_tail_rcu(&vlan->list, &port->vlans);
1522     update_port_bc_queue_len(vlan->port);
1523     netif_stacked_transfer_operstate(lowerdev, dev);
1524     linkwatch_fire_event(dev);
1525 
1526     return 0;
1527 
1528 unregister_netdev:
1529     /* macvlan_uninit would free the macvlan port */
1530     unregister_netdevice(dev);
1531     return err;
1532 destroy_macvlan_port:
1533     /* the macvlan port may be freed by macvlan_uninit when fail to register.
1534      * so we destroy the macvlan port only when it's valid.
1535      */
1536     if (create && macvlan_port_get_rtnl(lowerdev))
1537         macvlan_port_destroy(port->dev);
1538     return err;
1539 }
1540 EXPORT_SYMBOL_GPL(macvlan_common_newlink);
1541 
1542 static int macvlan_newlink(struct net *src_net, struct net_device *dev,
1543                struct nlattr *tb[], struct nlattr *data[],
1544                struct netlink_ext_ack *extack)
1545 {
1546     return macvlan_common_newlink(src_net, dev, tb, data, extack);
1547 }
1548 
1549 void macvlan_dellink(struct net_device *dev, struct list_head *head)
1550 {
1551     struct macvlan_dev *vlan = netdev_priv(dev);
1552 
1553     if (vlan->mode == MACVLAN_MODE_SOURCE)
1554         macvlan_flush_sources(vlan->port, vlan);
1555     list_del_rcu(&vlan->list);
1556     update_port_bc_queue_len(vlan->port);
1557     unregister_netdevice_queue(dev, head);
1558     netdev_upper_dev_unlink(vlan->lowerdev, dev);
1559 }
1560 EXPORT_SYMBOL_GPL(macvlan_dellink);
1561 
1562 static int macvlan_changelink(struct net_device *dev,
1563                   struct nlattr *tb[], struct nlattr *data[],
1564                   struct netlink_ext_ack *extack)
1565 {
1566     struct macvlan_dev *vlan = netdev_priv(dev);
1567     enum macvlan_mode mode;
1568     bool set_mode = false;
1569     enum macvlan_macaddr_mode macmode;
1570     int ret;
1571 
1572     /* Validate mode, but don't set yet: setting flags may fail. */
1573     if (data && data[IFLA_MACVLAN_MODE]) {
1574         set_mode = true;
1575         mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);
1576         /* Passthrough mode can't be set or cleared dynamically */
1577         if ((mode == MACVLAN_MODE_PASSTHRU) !=
1578             (vlan->mode == MACVLAN_MODE_PASSTHRU))
1579             return -EINVAL;
1580         if (vlan->mode == MACVLAN_MODE_SOURCE &&
1581             vlan->mode != mode)
1582             macvlan_flush_sources(vlan->port, vlan);
1583     }
1584 
1585     if (data && data[IFLA_MACVLAN_FLAGS]) {
1586         __u16 flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);
1587         bool promisc = (flags ^ vlan->flags) & MACVLAN_FLAG_NOPROMISC;
1588         if (macvlan_passthru(vlan->port) && promisc) {
1589             int err;
1590 
1591             if (flags & MACVLAN_FLAG_NOPROMISC)
1592                 err = dev_set_promiscuity(vlan->lowerdev, -1);
1593             else
1594                 err = dev_set_promiscuity(vlan->lowerdev, 1);
1595             if (err < 0)
1596                 return err;
1597         }
1598         vlan->flags = flags;
1599     }
1600 
1601     if (data && data[IFLA_MACVLAN_BC_QUEUE_LEN]) {
1602         vlan->bc_queue_len_req = nla_get_u32(data[IFLA_MACVLAN_BC_QUEUE_LEN]);
1603         update_port_bc_queue_len(vlan->port);
1604     }
1605 
1606     if (set_mode)
1607         vlan->mode = mode;
1608     if (data && data[IFLA_MACVLAN_MACADDR_MODE]) {
1609         if (vlan->mode != MACVLAN_MODE_SOURCE)
1610             return -EINVAL;
1611         macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]);
1612         ret = macvlan_changelink_sources(vlan, macmode, data);
1613         if (ret)
1614             return ret;
1615     }
1616     return 0;
1617 }
1618 
1619 static size_t macvlan_get_size_mac(const struct macvlan_dev *vlan)
1620 {
1621     if (vlan->macaddr_count == 0)
1622         return 0;
1623     return nla_total_size(0) /* IFLA_MACVLAN_MACADDR_DATA */
1624         + vlan->macaddr_count * nla_total_size(sizeof(u8) * ETH_ALEN);
1625 }
1626 
1627 static size_t macvlan_get_size(const struct net_device *dev)
1628 {
1629     struct macvlan_dev *vlan = netdev_priv(dev);
1630 
1631     return (0
1632         + nla_total_size(4) /* IFLA_MACVLAN_MODE */
1633         + nla_total_size(2) /* IFLA_MACVLAN_FLAGS */
1634         + nla_total_size(4) /* IFLA_MACVLAN_MACADDR_COUNT */
1635         + macvlan_get_size_mac(vlan) /* IFLA_MACVLAN_MACADDR */
1636         + nla_total_size(4) /* IFLA_MACVLAN_BC_QUEUE_LEN */
1637         + nla_total_size(4) /* IFLA_MACVLAN_BC_QUEUE_LEN_USED */
1638         );
1639 }
1640 
1641 static int macvlan_fill_info_macaddr(struct sk_buff *skb,
1642                      const struct macvlan_dev *vlan,
1643                      const int i)
1644 {
1645     struct hlist_head *h = &vlan->port->vlan_source_hash[i];
1646     struct macvlan_source_entry *entry;
1647 
1648     hlist_for_each_entry_rcu(entry, h, hlist) {
1649         if (entry->vlan != vlan)
1650             continue;
1651         if (nla_put(skb, IFLA_MACVLAN_MACADDR, ETH_ALEN, entry->addr))
1652             return 1;
1653     }
1654     return 0;
1655 }
1656 
1657 static int macvlan_fill_info(struct sk_buff *skb,
1658                 const struct net_device *dev)
1659 {
1660     struct macvlan_dev *vlan = netdev_priv(dev);
1661     struct macvlan_port *port = vlan->port;
1662     int i;
1663     struct nlattr *nest;
1664 
1665     if (nla_put_u32(skb, IFLA_MACVLAN_MODE, vlan->mode))
1666         goto nla_put_failure;
1667     if (nla_put_u16(skb, IFLA_MACVLAN_FLAGS, vlan->flags))
1668         goto nla_put_failure;
1669     if (nla_put_u32(skb, IFLA_MACVLAN_MACADDR_COUNT, vlan->macaddr_count))
1670         goto nla_put_failure;
1671     if (vlan->macaddr_count > 0) {
1672         nest = nla_nest_start_noflag(skb, IFLA_MACVLAN_MACADDR_DATA);
1673         if (nest == NULL)
1674             goto nla_put_failure;
1675 
1676         for (i = 0; i < MACVLAN_HASH_SIZE; i++) {
1677             if (macvlan_fill_info_macaddr(skb, vlan, i))
1678                 goto nla_put_failure;
1679         }
1680         nla_nest_end(skb, nest);
1681     }
1682     if (nla_put_u32(skb, IFLA_MACVLAN_BC_QUEUE_LEN, vlan->bc_queue_len_req))
1683         goto nla_put_failure;
1684     if (nla_put_u32(skb, IFLA_MACVLAN_BC_QUEUE_LEN_USED, port->bc_queue_len_used))
1685         goto nla_put_failure;
1686     return 0;
1687 
1688 nla_put_failure:
1689     return -EMSGSIZE;
1690 }
1691 
1692 static const struct nla_policy macvlan_policy[IFLA_MACVLAN_MAX + 1] = {
1693     [IFLA_MACVLAN_MODE]  = { .type = NLA_U32 },
1694     [IFLA_MACVLAN_FLAGS] = { .type = NLA_U16 },
1695     [IFLA_MACVLAN_MACADDR_MODE] = { .type = NLA_U32 },
1696     [IFLA_MACVLAN_MACADDR] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1697     [IFLA_MACVLAN_MACADDR_DATA] = { .type = NLA_NESTED },
1698     [IFLA_MACVLAN_MACADDR_COUNT] = { .type = NLA_U32 },
1699     [IFLA_MACVLAN_BC_QUEUE_LEN] = { .type = NLA_U32 },
1700     [IFLA_MACVLAN_BC_QUEUE_LEN_USED] = { .type = NLA_REJECT },
1701 };
1702 
1703 int macvlan_link_register(struct rtnl_link_ops *ops)
1704 {
1705     /* common fields */
1706     ops->validate       = macvlan_validate;
1707     ops->maxtype        = IFLA_MACVLAN_MAX;
1708     ops->policy     = macvlan_policy;
1709     ops->changelink     = macvlan_changelink;
1710     ops->get_size       = macvlan_get_size;
1711     ops->fill_info      = macvlan_fill_info;
1712 
1713     return rtnl_link_register(ops);
1714 };
1715 EXPORT_SYMBOL_GPL(macvlan_link_register);
1716 
1717 static struct net *macvlan_get_link_net(const struct net_device *dev)
1718 {
1719     return dev_net(macvlan_dev_real_dev(dev));
1720 }
1721 
1722 static struct rtnl_link_ops macvlan_link_ops = {
1723     .kind       = "macvlan",
1724     .setup      = macvlan_setup,
1725     .newlink    = macvlan_newlink,
1726     .dellink    = macvlan_dellink,
1727     .get_link_net   = macvlan_get_link_net,
1728     .priv_size      = sizeof(struct macvlan_dev),
1729 };
1730 
1731 static void update_port_bc_queue_len(struct macvlan_port *port)
1732 {
1733     u32 max_bc_queue_len_req = 0;
1734     struct macvlan_dev *vlan;
1735 
1736     list_for_each_entry(vlan, &port->vlans, list) {
1737         if (vlan->bc_queue_len_req > max_bc_queue_len_req)
1738             max_bc_queue_len_req = vlan->bc_queue_len_req;
1739     }
1740     port->bc_queue_len_used = max_bc_queue_len_req;
1741 }
1742 
1743 static int macvlan_device_event(struct notifier_block *unused,
1744                 unsigned long event, void *ptr)
1745 {
1746     struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1747     struct macvlan_dev *vlan, *next;
1748     struct macvlan_port *port;
1749     LIST_HEAD(list_kill);
1750 
1751     if (!netif_is_macvlan_port(dev))
1752         return NOTIFY_DONE;
1753 
1754     port = macvlan_port_get_rtnl(dev);
1755 
1756     switch (event) {
1757     case NETDEV_UP:
1758     case NETDEV_DOWN:
1759     case NETDEV_CHANGE:
1760         list_for_each_entry(vlan, &port->vlans, list)
1761             netif_stacked_transfer_operstate(vlan->lowerdev,
1762                              vlan->dev);
1763         break;
1764     case NETDEV_FEAT_CHANGE:
1765         list_for_each_entry(vlan, &port->vlans, list) {
1766             netif_inherit_tso_max(vlan->dev, dev);
1767             netdev_update_features(vlan->dev);
1768         }
1769         break;
1770     case NETDEV_CHANGEMTU:
1771         list_for_each_entry(vlan, &port->vlans, list) {
1772             if (vlan->dev->mtu <= dev->mtu)
1773                 continue;
1774             dev_set_mtu(vlan->dev, dev->mtu);
1775         }
1776         break;
1777     case NETDEV_CHANGEADDR:
1778         if (!macvlan_passthru(port))
1779             return NOTIFY_DONE;
1780 
1781         vlan = list_first_entry_or_null(&port->vlans,
1782                         struct macvlan_dev,
1783                         list);
1784 
1785         if (vlan && macvlan_sync_address(vlan->dev, dev->dev_addr))
1786             return NOTIFY_BAD;
1787 
1788         break;
1789     case NETDEV_UNREGISTER:
1790         /* twiddle thumbs on netns device moves */
1791         if (dev->reg_state != NETREG_UNREGISTERING)
1792             break;
1793 
1794         list_for_each_entry_safe(vlan, next, &port->vlans, list)
1795             vlan->dev->rtnl_link_ops->dellink(vlan->dev, &list_kill);
1796         unregister_netdevice_many(&list_kill);
1797         break;
1798     case NETDEV_PRE_TYPE_CHANGE:
1799         /* Forbid underlying device to change its type. */
1800         return NOTIFY_BAD;
1801 
1802     case NETDEV_NOTIFY_PEERS:
1803     case NETDEV_BONDING_FAILOVER:
1804     case NETDEV_RESEND_IGMP:
1805         /* Propagate to all vlans */
1806         list_for_each_entry(vlan, &port->vlans, list)
1807             call_netdevice_notifiers(event, vlan->dev);
1808     }
1809     return NOTIFY_DONE;
1810 }
1811 
1812 static struct notifier_block macvlan_notifier_block __read_mostly = {
1813     .notifier_call  = macvlan_device_event,
1814 };
1815 
1816 static int __init macvlan_init_module(void)
1817 {
1818     int err;
1819 
1820     register_netdevice_notifier(&macvlan_notifier_block);
1821 
1822     err = macvlan_link_register(&macvlan_link_ops);
1823     if (err < 0)
1824         goto err1;
1825     return 0;
1826 err1:
1827     unregister_netdevice_notifier(&macvlan_notifier_block);
1828     return err;
1829 }
1830 
1831 static void __exit macvlan_cleanup_module(void)
1832 {
1833     rtnl_link_unregister(&macvlan_link_ops);
1834     unregister_netdevice_notifier(&macvlan_notifier_block);
1835 }
1836 
1837 module_init(macvlan_init_module);
1838 module_exit(macvlan_cleanup_module);
1839 
1840 MODULE_LICENSE("GPL");
1841 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
1842 MODULE_DESCRIPTION("Driver for MAC address based VLANs");
1843 MODULE_ALIAS_RTNL_LINK("macvlan");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!