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