macvlan.c 40.2 KB
Newer Older
Patrick McHardy's avatar
Patrick McHardy committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * Copyright (c) 2007 Patrick McHardy <kaber@trash.net>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * The code this is based on carried the following copyright notice:
 * ---
 * (C) Copyright 2001-2006
 * Alex Zeffertt, Cambridge Broadband Ltd, ajz@cambridgebroadband.com
 * Re-worked by Ben Greear <greearb@candelatech.com>
 * ---
 */
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/string.h>
23
#include <linux/rculist.h>
Patrick McHardy's avatar
Patrick McHardy committed
24 25 26 27 28
#include <linux/notifier.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/if_arp.h>
29
#include <linux/if_vlan.h>
Patrick McHardy's avatar
Patrick McHardy committed
30 31
#include <linux/if_link.h>
#include <linux/if_macvlan.h>
Eric Dumazet's avatar
Eric Dumazet committed
32
#include <linux/hash.h>
33
#include <linux/workqueue.h>
Patrick McHardy's avatar
Patrick McHardy committed
34
#include <net/rtnetlink.h>
35
#include <net/xfrm.h>
dingtianhong's avatar
dingtianhong committed
36
#include <linux/netpoll.h>
Patrick McHardy's avatar
Patrick McHardy committed
37

Michael Braun's avatar
Michael Braun committed
38 39
#define MACVLAN_HASH_BITS	8
#define MACVLAN_HASH_SIZE	(1<<MACVLAN_HASH_BITS)
40
#define MACVLAN_BC_QUEUE_LEN	1000
Patrick McHardy's avatar
Patrick McHardy committed
41 42 43 44 45

struct macvlan_port {
	struct net_device	*dev;
	struct hlist_head	vlan_hash[MACVLAN_HASH_SIZE];
	struct list_head	vlans;
46
	struct rcu_head		rcu;
47 48
	struct sk_buff_head	bc_queue;
	struct work_struct	bc_work;
49
	bool 			passthru;
50
	int			count;
Michael Braun's avatar
Michael Braun committed
51 52 53 54 55 56 57 58
	struct hlist_head	vlan_source_hash[MACVLAN_HASH_SIZE];
};

struct macvlan_source_entry {
	struct hlist_node	hlist;
	struct macvlan_dev	*vlan;
	unsigned char		addr[6+2] __aligned(sizeof(u16));
	struct rcu_head		rcu;
Patrick McHardy's avatar
Patrick McHardy committed
59 60
};

61 62 63 64 65 66
struct macvlan_skb_cb {
	const struct macvlan_dev *src;
};

#define MACVLAN_SKB_CB(__skb) ((struct macvlan_skb_cb *)&((__skb)->cb[0]))

67 68
static void macvlan_port_destroy(struct net_device *dev);

Michael Braun's avatar
Michael Braun committed
69 70 71 72 73 74 75 76 77 78 79 80 81 82
/* Hash Ethernet address */
static u32 macvlan_eth_hash(const unsigned char *addr)
{
	u64 value = get_unaligned((u64 *)addr);

	/* only want 6 bytes */
#ifdef __BIG_ENDIAN
	value >>= 16;
#else
	value <<= 16;
#endif
	return hash_64(value, MACVLAN_HASH_BITS);
}

83 84 85 86 87 88 89 90 91 92
static struct macvlan_port *macvlan_port_get_rcu(const struct net_device *dev)
{
	return rcu_dereference(dev->rx_handler_data);
}

static struct macvlan_port *macvlan_port_get_rtnl(const struct net_device *dev)
{
	return rtnl_dereference(dev->rx_handler_data);
}

93 94
#define macvlan_port_exists(dev) (dev->priv_flags & IFF_MACVLAN_PORT)

Patrick McHardy's avatar
Patrick McHardy committed
95 96 97 98
static struct macvlan_dev *macvlan_hash_lookup(const struct macvlan_port *port,
					       const unsigned char *addr)
{
	struct macvlan_dev *vlan;
Michael Braun's avatar
Michael Braun committed
99
	u32 idx = macvlan_eth_hash(addr);
Patrick McHardy's avatar
Patrick McHardy committed
100

Michael Braun's avatar
Michael Braun committed
101
	hlist_for_each_entry_rcu(vlan, &port->vlan_hash[idx], hlist) {
102
		if (ether_addr_equal_64bits(vlan->dev->dev_addr, addr))
Patrick McHardy's avatar
Patrick McHardy committed
103 104 105 106 107
			return vlan;
	}
	return NULL;
}

Michael Braun's avatar
Michael Braun committed
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
static struct macvlan_source_entry *macvlan_hash_lookup_source(
	const struct macvlan_dev *vlan,
	const unsigned char *addr)
{
	struct macvlan_source_entry *entry;
	u32 idx = macvlan_eth_hash(addr);
	struct hlist_head *h = &vlan->port->vlan_source_hash[idx];

	hlist_for_each_entry_rcu(entry, h, hlist) {
		if (ether_addr_equal_64bits(entry->addr, addr) &&
		    entry->vlan == vlan)
			return entry;
	}
	return NULL;
}

static int macvlan_hash_add_source(struct macvlan_dev *vlan,
				   const unsigned char *addr)
{
	struct macvlan_port *port = vlan->port;
	struct macvlan_source_entry *entry;
	struct hlist_head *h;

	entry = macvlan_hash_lookup_source(vlan, addr);
	if (entry)
		return 0;

	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
	if (!entry)
		return -ENOMEM;

	ether_addr_copy(entry->addr, addr);
	entry->vlan = vlan;
	h = &port->vlan_source_hash[macvlan_eth_hash(addr)];
	hlist_add_head_rcu(&entry->hlist, h);
	vlan->macaddr_count++;

	return 0;
}

148 149 150 151
static void macvlan_hash_add(struct macvlan_dev *vlan)
{
	struct macvlan_port *port = vlan->port;
	const unsigned char *addr = vlan->dev->dev_addr;
Michael Braun's avatar
Michael Braun committed
152
	u32 idx = macvlan_eth_hash(addr);
153

Michael Braun's avatar
Michael Braun committed
154 155 156 157 158 159 160
	hlist_add_head_rcu(&vlan->hlist, &port->vlan_hash[idx]);
}

static void macvlan_hash_del_source(struct macvlan_source_entry *entry)
{
	hlist_del_rcu(&entry->hlist);
	kfree_rcu(entry, rcu);
161 162
}

163
static void macvlan_hash_del(struct macvlan_dev *vlan, bool sync)
164 165
{
	hlist_del_rcu(&vlan->hlist);
166 167
	if (sync)
		synchronize_rcu();
168 169 170 171 172
}

static void macvlan_hash_change_addr(struct macvlan_dev *vlan,
					const unsigned char *addr)
{
173
	macvlan_hash_del(vlan, true);
174 175 176 177 178 179 180 181 182 183 184 185 186 187
	/* Now that we are unhashed it is safe to change the device
	 * address without confusing packet delivery.
	 */
	memcpy(vlan->dev->dev_addr, addr, ETH_ALEN);
	macvlan_hash_add(vlan);
}

static int macvlan_addr_busy(const struct macvlan_port *port,
				const unsigned char *addr)
{
	/* Test to see if the specified multicast address is
	 * currently in use by the underlying device or
	 * another macvlan.
	 */
188
	if (ether_addr_equal_64bits(port->dev->dev_addr, addr))
189 190 191 192 193 194 195 196
		return 1;

	if (macvlan_hash_lookup(port, addr))
		return 1;

	return 0;
}

197

198 199
static int macvlan_broadcast_one(struct sk_buff *skb,
				 const struct macvlan_dev *vlan,
200
				 const struct ethhdr *eth, bool local)
201
{
202
	struct net_device *dev = vlan->dev;
203

204
	if (local)
205
		return __dev_forward_skb(dev, skb);
206

207
	skb->dev = dev;
208
	if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast))
209 210 211 212
		skb->pkt_type = PACKET_BROADCAST;
	else
		skb->pkt_type = PACKET_MULTICAST;

213
	return 0;
214 215
}

216 217 218 219 220 221 222 223
static u32 macvlan_hash_mix(const struct macvlan_dev *vlan)
{
	return (u32)(((unsigned long)vlan) >> L1_CACHE_SHIFT);
}


static unsigned int mc_hash(const struct macvlan_dev *vlan,
			    const unsigned char *addr)
Eric Dumazet's avatar
Eric Dumazet committed
224 225 226
{
	u32 val = __get_unaligned_cpu32(addr + 2);

227
	val ^= macvlan_hash_mix(vlan);
Eric Dumazet's avatar
Eric Dumazet committed
228 229 230
	return hash_32(val, MACVLAN_MC_FILTER_BITS);
}

Patrick McHardy's avatar
Patrick McHardy committed
231
static void macvlan_broadcast(struct sk_buff *skb,
232 233 234
			      const struct macvlan_port *port,
			      struct net_device *src,
			      enum macvlan_mode mode)
Patrick McHardy's avatar
Patrick McHardy committed
235
{
236
	const struct ethhdr *eth = skb_eth_hdr(skb);
Patrick McHardy's avatar
Patrick McHardy committed
237 238 239
	const struct macvlan_dev *vlan;
	struct sk_buff *nskb;
	unsigned int i;
240
	int err;
241
	unsigned int hash;
Patrick McHardy's avatar
Patrick McHardy committed
242

243 244 245
	if (skb->protocol == htons(ETH_P_PAUSE))
		return;

Patrick McHardy's avatar
Patrick McHardy committed
246
	for (i = 0; i < MACVLAN_HASH_SIZE; i++) {
247
		hlist_for_each_entry_rcu(vlan, &port->vlan_hash[i], hlist) {
248 249 250
			if (vlan->dev == src || !(vlan->mode & mode))
				continue;

251
			hash = mc_hash(vlan, eth->h_dest);
Eric Dumazet's avatar
Eric Dumazet committed
252 253
			if (!test_bit(hash, vlan->mc_filter))
				continue;
254 255

			err = NET_RX_DROP;
Patrick McHardy's avatar
Patrick McHardy committed
256
			nskb = skb_clone(skb, GFP_ATOMIC);
257 258 259
			if (likely(nskb))
				err = macvlan_broadcast_one(
					nskb, vlan, eth,
260 261
					mode == MACVLAN_MODE_BRIDGE) ?:
				      netif_rx_ni(nskb);
262
			macvlan_count_rx(vlan, skb->len + ETH_HLEN,
263
					 err == NET_RX_SUCCESS, true);
Patrick McHardy's avatar
Patrick McHardy committed
264 265 266 267
		}
	}
}

268
static void macvlan_process_broadcast(struct work_struct *w)
Patrick McHardy's avatar
Patrick McHardy committed
269
{
270 271 272 273 274
	struct macvlan_port *port = container_of(w, struct macvlan_port,
						 bc_work);
	struct sk_buff *skb;
	struct sk_buff_head list;

275
	__skb_queue_head_init(&list);
276 277 278 279 280 281 282 283 284

	spin_lock_bh(&port->bc_queue.lock);
	skb_queue_splice_tail_init(&port->bc_queue, &list);
	spin_unlock_bh(&port->bc_queue.lock);

	while ((skb = __skb_dequeue(&list))) {
		const struct macvlan_dev *src = MACVLAN_SKB_CB(skb)->src;

		rcu_read_lock();
Patrick McHardy's avatar
Patrick McHardy committed
285

286 287 288 289 290
		if (!src)
			/* frame comes from an external address */
			macvlan_broadcast(skb, port, NULL,
					  MACVLAN_MODE_PRIVATE |
					  MACVLAN_MODE_VEPA    |
291
					  MACVLAN_MODE_PASSTHRU|
292 293 294 295 296 297
					  MACVLAN_MODE_BRIDGE);
		else if (src->mode == MACVLAN_MODE_VEPA)
			/* flood to everyone except source */
			macvlan_broadcast(skb, port, src->dev,
					  MACVLAN_MODE_VEPA |
					  MACVLAN_MODE_BRIDGE);
298
		else
299 300 301 302 303 304
			/*
			 * flood only to VEPA ports, bridge ports
			 * already saw the frame on the way out.
			 */
			macvlan_broadcast(skb, port, src->dev,
					  MACVLAN_MODE_VEPA);
305 306 307 308 309 310 311 312 313 314

		rcu_read_unlock();

		kfree_skb(skb);
	}
}

static void macvlan_broadcast_enqueue(struct macvlan_port *port,
				      struct sk_buff *skb)
{
315
	struct sk_buff *nskb;
316 317
	int err = -ENOMEM;

318 319
	nskb = skb_clone(skb, GFP_ATOMIC);
	if (!nskb)
320 321 322
		goto err;

	spin_lock(&port->bc_queue.lock);
323
	if (skb_queue_len(&port->bc_queue) < MACVLAN_BC_QUEUE_LEN) {
324
		__skb_queue_tail(&port->bc_queue, nskb);
325 326 327 328
		err = 0;
	}
	spin_unlock(&port->bc_queue.lock);

329 330
	schedule_work(&port->bc_work);

331
	if (err)
332
		goto free_nskb;
333 334 335

	return;

336 337
free_nskb:
	kfree_skb(nskb);
338 339 340 341
err:
	atomic_long_inc(&skb->dev->rx_dropped);
}

Michael Braun's avatar
Michael Braun committed
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
static void macvlan_flush_sources(struct macvlan_port *port,
				  struct macvlan_dev *vlan)
{
	int i;

	for (i = 0; i < MACVLAN_HASH_SIZE; i++) {
		struct hlist_node *h, *n;

		hlist_for_each_safe(h, n, &port->vlan_source_hash[i]) {
			struct macvlan_source_entry *entry;

			entry = hlist_entry(h, struct macvlan_source_entry,
					    hlist);
			if (entry->vlan == vlan)
				macvlan_hash_del_source(entry);
		}
	}
	vlan->macaddr_count = 0;
}

static void macvlan_forward_source_one(struct sk_buff *skb,
				       struct macvlan_dev *vlan)
{
	struct sk_buff *nskb;
	struct net_device *dev;
	int len;
	int ret;

	dev = vlan->dev;
	if (unlikely(!(dev->flags & IFF_UP)))
		return;

	nskb = skb_clone(skb, GFP_ATOMIC);
	if (!nskb)
		return;

	len = nskb->len + ETH_HLEN;
	nskb->dev = dev;
	nskb->pkt_type = PACKET_HOST;

	ret = netif_rx(nskb);
383
	macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false);
Michael Braun's avatar
Michael Braun committed
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
}

static void macvlan_forward_source(struct sk_buff *skb,
				   struct macvlan_port *port,
				   const unsigned char *addr)
{
	struct macvlan_source_entry *entry;
	u32 idx = macvlan_eth_hash(addr);
	struct hlist_head *h = &port->vlan_source_hash[idx];

	hlist_for_each_entry_rcu(entry, h, hlist) {
		if (ether_addr_equal_64bits(entry->addr, addr))
			if (entry->vlan->dev->flags & IFF_UP)
				macvlan_forward_source_one(skb, entry->vlan);
	}
}

401 402 403 404 405 406 407 408 409 410
/* called under rcu_read_lock() from netif_receive_skb */
static rx_handler_result_t macvlan_handle_frame(struct sk_buff **pskb)
{
	struct macvlan_port *port;
	struct sk_buff *skb = *pskb;
	const struct ethhdr *eth = eth_hdr(skb);
	const struct macvlan_dev *vlan;
	const struct macvlan_dev *src;
	struct net_device *dev;
	unsigned int len = 0;
411 412
	int ret;
	rx_handler_result_t handle_res;
413 414 415

	port = macvlan_port_get_rcu(skb->dev);
	if (is_multicast_ether_addr(eth->h_dest)) {
416
		skb = ip_check_defrag(dev_net(skb->dev), skb, IP_DEFRAG_MACVLAN);
417 418
		if (!skb)
			return RX_HANDLER_CONSUMED;
419
		*pskb = skb;
420
		eth = eth_hdr(skb);
Michael Braun's avatar
Michael Braun committed
421
		macvlan_forward_source(skb, port, eth->h_source);
422 423 424
		src = macvlan_hash_lookup(port, eth->h_source);
		if (src && src->mode != MACVLAN_MODE_VEPA &&
		    src->mode != MACVLAN_MODE_BRIDGE) {
425 426
			/* forward to original port. */
			vlan = src;
427 428
			ret = macvlan_broadcast_one(skb, vlan, eth, 0) ?:
			      netif_rx(skb);
429
			handle_res = RX_HANDLER_CONSUMED;
430 431 432
			goto out;
		}

433 434 435
		MACVLAN_SKB_CB(skb)->src = src;
		macvlan_broadcast_enqueue(port, skb);

436
		return RX_HANDLER_PASS;
Patrick McHardy's avatar
Patrick McHardy committed
437 438
	}

Michael Braun's avatar
Michael Braun committed
439
	macvlan_forward_source(skb, port, eth->h_source);
440
	if (port->passthru)
441 442
		vlan = list_first_or_null_rcu(&port->vlans,
					      struct macvlan_dev, list);
443 444
	else
		vlan = macvlan_hash_lookup(port, eth->h_dest);
445
	if (!vlan || vlan->mode == MACVLAN_MODE_SOURCE)
446
		return RX_HANDLER_PASS;
Patrick McHardy's avatar
Patrick McHardy committed
447 448 449 450

	dev = vlan->dev;
	if (unlikely(!(dev->flags & IFF_UP))) {
		kfree_skb(skb);
451
		return RX_HANDLER_CONSUMED;
Patrick McHardy's avatar
Patrick McHardy committed
452
	}
453
	len = skb->len + ETH_HLEN;
Patrick McHardy's avatar
Patrick McHardy committed
454
	skb = skb_share_check(skb, GFP_ATOMIC);
455 456 457
	if (!skb) {
		ret = NET_RX_DROP;
		handle_res = RX_HANDLER_CONSUMED;
458
		goto out;
459
	}
Patrick McHardy's avatar
Patrick McHardy committed
460

461
	*pskb = skb;
Patrick McHardy's avatar
Patrick McHardy committed
462 463 464
	skb->dev = dev;
	skb->pkt_type = PACKET_HOST;

465 466
	ret = NET_RX_SUCCESS;
	handle_res = RX_HANDLER_ANOTHER;
467
out:
468
	macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false);
469
	return handle_res;
Patrick McHardy's avatar
Patrick McHardy committed
470 471
}

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
static int macvlan_queue_xmit(struct sk_buff *skb, struct net_device *dev)
{
	const struct macvlan_dev *vlan = netdev_priv(dev);
	const struct macvlan_port *port = vlan->port;
	const struct macvlan_dev *dest;

	if (vlan->mode == MACVLAN_MODE_BRIDGE) {
		const struct ethhdr *eth = (void *)skb->data;

		/* send to other bridge ports directly */
		if (is_multicast_ether_addr(eth->h_dest)) {
			macvlan_broadcast(skb, port, dev, MACVLAN_MODE_BRIDGE);
			goto xmit_world;
		}

		dest = macvlan_hash_lookup(port, eth->h_dest);
		if (dest && dest->mode == MACVLAN_MODE_BRIDGE) {
489
			/* send to lowerdev first for its network taps */
490
			dev_forward_skb(vlan->lowerdev, skb);
491 492 493 494 495 496

			return NET_XMIT_SUCCESS;
		}
	}

xmit_world:
497
	skb->dev = vlan->lowerdev;
498 499 500
	return dev_queue_xmit(skb);
}

dingtianhong's avatar
dingtianhong committed
501 502 503 504 505 506 507 508 509 510 511
static inline netdev_tx_t macvlan_netpoll_send_skb(struct macvlan_dev *vlan, struct sk_buff *skb)
{
#ifdef CONFIG_NET_POLL_CONTROLLER
	if (vlan->netpoll)
		netpoll_send_skb(vlan->netpoll, skb);
#else
	BUG();
#endif
	return NETDEV_TX_OK;
}

512 513
static netdev_tx_t macvlan_start_xmit(struct sk_buff *skb,
				      struct net_device *dev)
Patrick McHardy's avatar
Patrick McHardy committed
514 515 516
{
	unsigned int len = skb->len;
	int ret;
dingtianhong's avatar
dingtianhong committed
517 518 519 520
	struct macvlan_dev *vlan = netdev_priv(dev);

	if (unlikely(netpoll_tx_running(dev)))
		return macvlan_netpoll_send_skb(vlan, skb);
Patrick McHardy's avatar
Patrick McHardy committed
521

522 523
	if (vlan->fwd_priv) {
		skb->dev = vlan->lowerdev;
524
		ret = dev_queue_xmit_accel(skb, vlan->fwd_priv);
525 526 527 528
	} else {
		ret = macvlan_queue_xmit(skb, dev);
	}

529
	if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
530
		struct vlan_pcpu_stats *pcpu_stats;
531

Eric Dumazet's avatar
Eric Dumazet committed
532 533 534 535 536 537 538 539
		pcpu_stats = this_cpu_ptr(vlan->pcpu_stats);
		u64_stats_update_begin(&pcpu_stats->syncp);
		pcpu_stats->tx_packets++;
		pcpu_stats->tx_bytes += len;
		u64_stats_update_end(&pcpu_stats->syncp);
	} else {
		this_cpu_inc(vlan->pcpu_stats->tx_dropped);
	}
540
	return ret;
Patrick McHardy's avatar
Patrick McHardy committed
541 542 543
}

static int macvlan_hard_header(struct sk_buff *skb, struct net_device *dev,
544 545
			       unsigned short type, const void *daddr,
			       const void *saddr, unsigned len)
Patrick McHardy's avatar
Patrick McHardy committed
546 547 548 549
{
	const struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

550 551
	return dev_hard_header(skb, lowerdev, type, daddr,
			       saddr ? : dev->dev_addr, len);
Patrick McHardy's avatar
Patrick McHardy committed
552 553
}

554 555 556 557 558 559 560
static const struct header_ops macvlan_hard_header_ops = {
	.create  	= macvlan_hard_header,
	.parse		= eth_header_parse,
	.cache		= eth_header_cache,
	.cache_update	= eth_header_cache_update,
};

561 562
static struct rtnl_link_ops macvlan_link_ops;

Patrick McHardy's avatar
Patrick McHardy committed
563 564 565 566 567 568
static int macvlan_open(struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;
	int err;

569
	if (vlan->port->passthru) {
570 571 572 573 574
		if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC)) {
			err = dev_set_promiscuity(lowerdev, 1);
			if (err < 0)
				goto out;
		}
575 576 577
		goto hash_add;
	}

578 579
	if (lowerdev->features & NETIF_F_HW_L2FW_DOFFLOAD &&
	    dev->rtnl_link_ops == &macvlan_link_ops) {
580 581 582 583 584 585 586 587
		vlan->fwd_priv =
		      lowerdev->netdev_ops->ndo_dfwd_add_station(lowerdev, dev);

		/* If we get a NULL pointer back, or if we get an error
		 * then we should just fall through to the non accelerated path
		 */
		if (IS_ERR_OR_NULL(vlan->fwd_priv)) {
			vlan->fwd_priv = NULL;
588
		} else
589 590 591
			return 0;
	}

592 593 594 595
	err = -EBUSY;
	if (macvlan_addr_busy(vlan->port, dev->dev_addr))
		goto out;

596
	err = dev_uc_add(lowerdev, dev->dev_addr);
Patrick McHardy's avatar
Patrick McHardy committed
597
	if (err < 0)
598 599 600 601 602 603
		goto out;
	if (dev->flags & IFF_ALLMULTI) {
		err = dev_set_allmulti(lowerdev, 1);
		if (err < 0)
			goto del_unicast;
	}
604

605 606 607 608 609 610
	if (dev->flags & IFF_PROMISC) {
		err = dev_set_promiscuity(lowerdev, 1);
		if (err < 0)
			goto clear_multi;
	}

611
hash_add:
612
	macvlan_hash_add(vlan);
Patrick McHardy's avatar
Patrick McHardy committed
613
	return 0;
614

615 616
clear_multi:
	dev_set_allmulti(lowerdev, -1);
617
del_unicast:
618
	dev_uc_del(lowerdev, dev->dev_addr);
619
out:
620 621 622 623 624
	if (vlan->fwd_priv) {
		lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev,
							   vlan->fwd_priv);
		vlan->fwd_priv = NULL;
	}
625
	return err;
Patrick McHardy's avatar
Patrick McHardy committed
626 627 628 629 630 631 632
}

static int macvlan_stop(struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

633 634 635 636 637 638 639
	if (vlan->fwd_priv) {
		lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev,
							   vlan->fwd_priv);
		vlan->fwd_priv = NULL;
		return 0;
	}

640 641 642
	dev_uc_unsync(lowerdev, dev);
	dev_mc_unsync(lowerdev, dev);

643
	if (vlan->port->passthru) {
644 645
		if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC))
			dev_set_promiscuity(lowerdev, -1);
646 647 648
		goto hash_del;
	}

Patrick McHardy's avatar
Patrick McHardy committed
649 650 651
	if (dev->flags & IFF_ALLMULTI)
		dev_set_allmulti(lowerdev, -1);

652 653 654
	if (dev->flags & IFF_PROMISC)
		dev_set_promiscuity(lowerdev, -1);

655
	dev_uc_del(lowerdev, dev->dev_addr);
Patrick McHardy's avatar
Patrick McHardy committed
656

657
hash_del:
658
	macvlan_hash_del(vlan, !dev->dismantle);
Patrick McHardy's avatar
Patrick McHardy committed
659 660 661
	return 0;
}

662
static int macvlan_sync_address(struct net_device *dev, unsigned char *addr)
663 664 665 666 667
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;
	int err;

668 669
	if (!(dev->flags & IFF_UP)) {
		/* Just copy in the new address */
670
		ether_addr_copy(dev->dev_addr, addr);
671 672
	} else {
		/* Rehash and update the device filters */
673
		if (macvlan_addr_busy(vlan->port, addr))
674
			return -EBUSY;
675

676 677 678 679
		if (!vlan->port->passthru) {
			err = dev_uc_add(lowerdev, addr);
			if (err)
				return err;
680

681 682
			dev_uc_del(lowerdev, dev->dev_addr);
		}
683

684
		macvlan_hash_change_addr(vlan, addr);
685
	}
686 687 688
	return 0;
}

689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
static int macvlan_set_mac_address(struct net_device *dev, void *p)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct sockaddr *addr = p;

	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

	if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
		dev_set_mac_address(vlan->lowerdev, addr);
		return 0;
	}

	return macvlan_sync_address(dev, addr->sa_data);
}

Patrick McHardy's avatar
Patrick McHardy committed
705 706 707 708 709
static void macvlan_change_rx_flags(struct net_device *dev, int change)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

710 711 712
	if (dev->flags & IFF_UP) {
		if (change & IFF_ALLMULTI)
			dev_set_allmulti(lowerdev, dev->flags & IFF_ALLMULTI ? 1 : -1);
713 714 715 716
		if (change & IFF_PROMISC)
			dev_set_promiscuity(lowerdev,
					    dev->flags & IFF_PROMISC ? 1 : -1);

717
	}
Patrick McHardy's avatar
Patrick McHardy committed
718 719
}

720
static void macvlan_set_mac_lists(struct net_device *dev)
Patrick McHardy's avatar
Patrick McHardy committed
721 722 723
{
	struct macvlan_dev *vlan = netdev_priv(dev);

Eric Dumazet's avatar
Eric Dumazet committed
724 725 726 727 728 729 730 731
	if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
		bitmap_fill(vlan->mc_filter, MACVLAN_MC_FILTER_SZ);
	} else {
		struct netdev_hw_addr *ha;
		DECLARE_BITMAP(filter, MACVLAN_MC_FILTER_SZ);

		bitmap_zero(filter, MACVLAN_MC_FILTER_SZ);
		netdev_for_each_mc_addr(ha, dev) {
732
			__set_bit(mc_hash(vlan, ha->addr), filter);
Eric Dumazet's avatar
Eric Dumazet committed
733
		}
734

735
		__set_bit(mc_hash(vlan, dev->broadcast), filter);
736

Eric Dumazet's avatar
Eric Dumazet committed
737 738
		bitmap_copy(vlan->mc_filter, filter, MACVLAN_MC_FILTER_SZ);
	}
739
	dev_uc_sync(vlan->lowerdev, dev);
Patrick McHardy's avatar
Patrick McHardy committed
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
	dev_mc_sync(vlan->lowerdev, dev);
}

static int macvlan_change_mtu(struct net_device *dev, int new_mtu)
{
	struct macvlan_dev *vlan = netdev_priv(dev);

	if (new_mtu < 68 || vlan->lowerdev->mtu < new_mtu)
		return -EINVAL;
	dev->mtu = new_mtu;
	return 0;
}

/*
 * macvlan network devices have devices nesting below it and are a special
 * "super class" of normal network devices; split their locks off into a
 * separate class since they always nest.
 */
static struct lock_class_key macvlan_netdev_xmit_lock_key;
759
static struct lock_class_key macvlan_netdev_addr_lock_key;
Patrick McHardy's avatar
Patrick McHardy committed
760

761
#define ALWAYS_ON_FEATURES \
762 763
	(NETIF_F_SG | NETIF_F_GEN_CSUM | NETIF_F_GSO_SOFTWARE | NETIF_F_LLTX | \
	 NETIF_F_GSO_ROBUST)
764

Patrick McHardy's avatar
Patrick McHardy committed
765 766
#define MACVLAN_FEATURES \
	(NETIF_F_SG | NETIF_F_ALL_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
767
	 NETIF_F_GSO | NETIF_F_TSO | NETIF_F_UFO | NETIF_F_LRO | \
768
	 NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \
769
	 NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)
Patrick McHardy's avatar
Patrick McHardy committed
770 771 772 773

#define MACVLAN_STATE_MASK \
	((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT))

774 775 776 777 778
static int macvlan_get_nest_level(struct net_device *dev)
{
	return ((struct macvlan_dev *)netdev_priv(dev))->nest_level;
}

779 780 781
static void macvlan_set_lockdep_class_one(struct net_device *dev,
					  struct netdev_queue *txq,
					  void *_unused)
782 783 784 785 786 787 788
{
	lockdep_set_class(&txq->_xmit_lock,
			  &macvlan_netdev_xmit_lock_key);
}

static void macvlan_set_lockdep_class(struct net_device *dev)
{
789 790 791
	lockdep_set_class_and_subclass(&dev->addr_list_lock,
				       &macvlan_netdev_addr_lock_key,
				       macvlan_get_nest_level(dev));
792
	netdev_for_each_tx_queue(dev, macvlan_set_lockdep_class_one, NULL);
793 794
}

Patrick McHardy's avatar
Patrick McHardy committed
795 796 797 798 799 800 801 802
static int macvlan_init(struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	const struct net_device *lowerdev = vlan->lowerdev;

	dev->state		= (dev->state & ~MACVLAN_STATE_MASK) |
				  (lowerdev->state & MACVLAN_STATE_MASK);
	dev->features 		= lowerdev->features & MACVLAN_FEATURES;
803
	dev->features		|= ALWAYS_ON_FEATURES;
804
	dev->hw_features	|= NETIF_F_LRO;
805
	dev->vlan_features	= lowerdev->vlan_features & MACVLAN_FEATURES;
806
	dev->gso_max_size	= lowerdev->gso_max_size;
807
	dev->hard_header_len	= lowerdev->hard_header_len;
Patrick McHardy's avatar
Patrick McHardy committed
808

809 810
	macvlan_set_lockdep_class(dev);

811
	vlan->pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);
Eric Dumazet's avatar
Eric Dumazet committed
812
	if (!vlan->pcpu_stats)
813 814
		return -ENOMEM;

Patrick McHardy's avatar
Patrick McHardy committed
815 816 817
	return 0;
}

818 819 820
static void macvlan_uninit(struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
821
	struct macvlan_port *port = vlan->port;
822

Eric Dumazet's avatar
Eric Dumazet committed
823
	free_percpu(vlan->pcpu_stats);
824

Michael Braun's avatar
Michael Braun committed
825
	macvlan_flush_sources(port, vlan);
826 827
	port->count -= 1;
	if (!port->count)
828
		macvlan_port_destroy(port->dev);
829 830
}

831 832
static struct rtnl_link_stats64 *macvlan_dev_get_stats64(struct net_device *dev,
							 struct rtnl_link_stats64 *stats)
833 834 835
{
	struct macvlan_dev *vlan = netdev_priv(dev);

Eric Dumazet's avatar
Eric Dumazet committed
836
	if (vlan->pcpu_stats) {
837
		struct vlan_pcpu_stats *p;
Eric Dumazet's avatar
Eric Dumazet committed
838 839
		u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes;
		u32 rx_errors = 0, tx_dropped = 0;
Eric Dumazet's avatar
Eric Dumazet committed
840
		unsigned int start;
841 842 843
		int i;

		for_each_possible_cpu(i) {
Eric Dumazet's avatar
Eric Dumazet committed
844
			p = per_cpu_ptr(vlan->pcpu_stats, i);
Eric Dumazet's avatar
Eric Dumazet committed
845
			do {
846
				start = u64_stats_fetch_begin_irq(&p->syncp);
Eric Dumazet's avatar
Eric Dumazet committed
847 848 849
				rx_packets	= p->rx_packets;
				rx_bytes	= p->rx_bytes;
				rx_multicast	= p->rx_multicast;
Eric Dumazet's avatar
Eric Dumazet committed
850 851
				tx_packets	= p->tx_packets;
				tx_bytes	= p->tx_bytes;
852
			} while (u64_stats_fetch_retry_irq(&p->syncp, start));
Eric Dumazet's avatar
Eric Dumazet committed
853 854 855 856 857 858 859 860 861 862 863

			stats->rx_packets	+= rx_packets;
			stats->rx_bytes		+= rx_bytes;
			stats->multicast	+= rx_multicast;
			stats->tx_packets	+= tx_packets;
			stats->tx_bytes		+= tx_bytes;
			/* rx_errors & tx_dropped are u32, updated
			 * without syncp protection.
			 */
			rx_errors	+= p->rx_errors;
			tx_dropped	+= p->tx_dropped;
864
		}
Eric Dumazet's avatar
Eric Dumazet committed
865 866 867
		stats->rx_errors	= rx_errors;
		stats->rx_dropped	= rx_errors;
		stats->tx_dropped	= tx_dropped;
868 869 870 871
	}
	return stats;
}

872
static int macvlan_vlan_rx_add_vid(struct net_device *dev,
873
				   __be16 proto, u16 vid)
874 875 876 877
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

878
	return vlan_vid_add(lowerdev, proto, vid);
879 880
}

881
static int macvlan_vlan_rx_kill_vid(struct net_device *dev,
882
				    __be16 proto, u16 vid)
883 884 885 886
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

887
	vlan_vid_del(lowerdev, proto, vid);
888
	return 0;
889 890
}

891
static int macvlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
892
			   struct net_device *dev,
893
			   const unsigned char *addr, u16 vid,
894 895 896 897 898
			   u16 flags)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	int err = -EINVAL;

899 900 901 902
	/* Support unicast filter only on passthru devices.
	 * Multicast filter should be allowed on all devices.
	 */
	if (!vlan->port->passthru && is_unicast_ether_addr(addr))
903 904
		return -EOPNOTSUPP;

Thomas Richter's avatar
Thomas Richter committed
905 906 907
	if (flags & NLM_F_REPLACE)
		return -EOPNOTSUPP;

908 909 910 911 912 913 914 915
	if (is_unicast_ether_addr(addr))
		err = dev_uc_add_excl(dev, addr);
	else if (is_multicast_ether_addr(addr))
		err = dev_mc_add_excl(dev, addr);

	return err;
}

916
static int macvlan_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
917
			   struct net_device *dev,
918
			   const unsigned char *addr, u16 vid)
919 920 921 922
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	int err = -EINVAL;

923 924 925 926
	/* Support unicast filter only on passthru devices.
	 * Multicast filter should be allowed on all devices.
	 */
	if (!vlan->port->passthru && is_unicast_ether_addr(addr))
927 928 929 930 931 932 933 934 935 936
		return -EOPNOTSUPP;

	if (is_unicast_ether_addr(addr))
		err = dev_uc_del(dev, addr);
	else if (is_multicast_ether_addr(addr))
		err = dev_mc_del(dev, addr);

	return err;
}

Patrick McHardy's avatar
Patrick McHardy committed
937 938 939
static void macvlan_ethtool_get_drvinfo(struct net_device *dev,
					struct ethtool_drvinfo *drvinfo)
{
940 941
	strlcpy(drvinfo->driver, "macvlan", sizeof(drvinfo->driver));
	strlcpy(drvinfo->version, "0.1", sizeof(drvinfo->version));
Patrick McHardy's avatar
Patrick McHardy committed
942 943
}

944 945 946 947
static int macvlan_ethtool_get_settings(struct net_device *dev,
					struct ethtool_cmd *cmd)
{
	const struct macvlan_dev *vlan = netdev_priv(dev);
948 949

	return __ethtool_get_settings(vlan->lowerdev, cmd);
950 951
}

952 953 954 955
static netdev_features_t macvlan_fix_features(struct net_device *dev,
					      netdev_features_t features)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
956
	netdev_features_t lowerdev_features = vlan->lowerdev->features;
957
	netdev_features_t mask;
958

959 960 961 962
	features |= NETIF_F_ALL_FOR_ALL;
	features &= (vlan->set_features | ~MACVLAN_FEATURES);
	mask = features;

963 964
	lowerdev_features &= (features | ~NETIF_F_LRO);
	features = netdev_increment_features(lowerdev_features, features, mask);
965
	features |= ALWAYS_ON_FEATURES;
966
	features &= ~NETIF_F_NETNS_LOCAL;
967 968

	return features;
969 970
}

dingtianhong's avatar
dingtianhong committed
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
#ifdef CONFIG_NET_POLL_CONTROLLER
static void macvlan_dev_poll_controller(struct net_device *dev)
{
	return;
}

static int macvlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *real_dev = vlan->lowerdev;
	struct netpoll *netpoll;
	int err = 0;

	netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
	err = -ENOMEM;
	if (!netpoll)
		goto out;

	err = __netpoll_setup(netpoll, real_dev);
	if (err) {
		kfree(netpoll);
		goto out;
	}

	vlan->netpoll = netpoll;

out:
	return err;
}

static void macvlan_dev_netpoll_cleanup(struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct netpoll *netpoll = vlan->netpoll;

	if (!netpoll)
		return;

	vlan->netpoll = NULL;

	__netpoll_free_async(netpoll);
}
#endif	/* CONFIG_NET_POLL_CONTROLLER */

1015 1016 1017 1018 1019 1020 1021
static int macvlan_dev_get_iflink(const struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);

	return vlan->lowerdev->ifindex;
}

Patrick McHardy's avatar
Patrick McHardy committed
1022 1023
static const struct ethtool_ops macvlan_ethtool_ops = {
	.get_link		= ethtool_op_get_link,
1024
	.get_settings		= macvlan_ethtool_get_settings,
Patrick McHardy's avatar
Patrick McHardy committed
1025 1026 1027
	.get_drvinfo		= macvlan_ethtool_get_drvinfo,
};

1028 1029
static const struct net_device_ops macvlan_netdev_ops = {
	.ndo_init		= macvlan_init,
1030
	.ndo_uninit		= macvlan_uninit,
1031 1032
	.ndo_open		= macvlan_open,
	.ndo_stop		= macvlan_stop,
1033
	.ndo_start_xmit		= macvlan_start_xmit,
1034
	.ndo_change_mtu		= macvlan_change_mtu,
1035
	.ndo_fix_features	= macvlan_fix_features,
1036 1037
	.ndo_change_rx_flags	= macvlan_change_rx_flags,
	.ndo_set_mac_address	= macvlan_set_mac_address,
1038
	.ndo_set_rx_mode	= macvlan_set_mac_lists,
Eric Dumazet's avatar
Eric Dumazet committed
1039
	.ndo_get_stats64	= macvlan_dev_get_stats64,
1040
	.ndo_validate_addr	= eth_validate_addr,
1041 1042
	.ndo_vlan_rx_add_vid	= macvlan_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid	= macvlan_vlan_rx_kill_vid,
1043 1044 1045
	.ndo_fdb_add		= macvlan_fdb_add,
	.ndo_fdb_del		= macvlan_fdb_del,
	.ndo_fdb_dump		= ndo_dflt_fdb_dump,
1046
	.ndo_get_lock_subclass  = macvlan_get_nest_level,
dingtianhong's avatar
dingtianhong committed
1047 1048 1049 1050 1051
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= macvlan_dev_poll_controller,
	.ndo_netpoll_setup	= macvlan_dev_netpoll_setup,
	.ndo_netpoll_cleanup	= macvlan_dev_netpoll_cleanup,
#endif
1052
	.ndo_get_iflink		= macvlan_dev_get_iflink,
1053
	.ndo_features_check	= passthru_features_check,
1054 1055
};

1056
void macvlan_common_setup(struct net_device *dev)
Patrick McHardy's avatar
Patrick McHardy committed
1057 1058 1059
{
	ether_setup(dev);

1060 1061
	dev->priv_flags	       &= ~IFF_TX_SKB_SHARING;
	netif_keep_dst(dev);
1062
	dev->priv_flags	       |= IFF_UNICAST_FLT;
1063
	dev->netdev_ops		= &macvlan_netdev_ops;
Patrick McHardy's avatar
Patrick McHardy committed
1064
	dev->destructor		= free_netdev;
1065
	dev->header_ops		= &macvlan_hard_header_ops;
Patrick McHardy's avatar
Patrick McHardy committed
1066
	dev->ethtool_ops	= &macvlan_ethtool_ops;
1067 1068 1069 1070 1071 1072
}
EXPORT_SYMBOL_GPL(macvlan_common_setup);

static void macvlan_setup(struct net_device *dev)
{
	macvlan_common_setup(dev);
Patrick McHardy's avatar
Patrick McHardy committed
1073 1074 1075 1076 1077 1078 1079
	dev->tx_queue_len	= 0;
}

static int macvlan_port_create(struct net_device *dev)
{
	struct macvlan_port *port;
	unsigned int i;
1080
	int err;
Patrick McHardy's avatar
Patrick McHardy committed
1081 1082 1083 1084

	if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK)
		return -EINVAL;

1085 1086 1087
	if (netif_is_ipvlan_port(dev))
		return -EBUSY;

Patrick McHardy's avatar
Patrick McHardy committed
1088 1089 1090 1091
	port = kzalloc(sizeof(*port), GFP_KERNEL);
	if (port == NULL)
		return -ENOMEM;

1092
	port->passthru = false;
Patrick McHardy's avatar
Patrick McHardy committed
1093 1094 1095 1096
	port->dev = dev;
	INIT_LIST_HEAD(&port->vlans);
	for (i = 0; i < MACVLAN_HASH_SIZE; i++)
		INIT_HLIST_HEAD(&port->vlan_hash[i]);
Michael Braun's avatar
Michael Braun committed
1097 1098
	for (i = 0; i < MACVLAN_HASH_SIZE; i++)
		INIT_HLIST_HEAD(&port->vlan_source_hash[i]);
1099

1100 1101 1102
	skb_queue_head_init(&port->bc_queue);
	INIT_WORK(&port->bc_work, macvlan_process_broadcast);

1103 1104
	err = netdev_rx_handler_register(dev, macvlan_handle_frame, port);
	if (err)
1105
		kfree(port);
1106 1107
	else
		dev->priv_flags |= IFF_MACVLAN_PORT;
1108
	return err;
Patrick McHardy's avatar
Patrick McHardy committed
1109 1110 1111 1112
}

static void macvlan_port_destroy(struct net_device *dev)
{
1113
	struct macvlan_port *port = macvlan_port_get_rtnl(dev);
1114
	struct sk_buff *skb;
Patrick McHardy's avatar
Patrick McHardy committed
1115

1116
	dev->priv_flags &= ~IFF_MACVLAN_PORT;
1117
	netdev_rx_handler_unregister(dev);
1118 1119 1120 1121 1122

	/* After this point, no packet can schedule bc_work anymore,
	 * but we need to cancel it and purge left skbs if any.
	 */
	cancel_work_sync(&port->bc_work);
1123 1124 1125 1126 1127 1128 1129 1130 1131

	while ((skb = __skb_dequeue(&port->bc_queue))) {
		const struct macvlan_dev *src = MACVLAN_SKB_CB(skb)->src;

		if (src)
			dev_put(src->dev);

		kfree_skb(skb);
	}
1132

1133
	kfree_rcu(port, rcu);
Patrick McHardy's avatar
Patrick McHardy committed
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
}

static int macvlan_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;
		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}
1144

Michael S. Tsirkin's avatar
Michael S. Tsirkin committed
1145 1146 1147 1148
	if (data && data[IFLA_MACVLAN_FLAGS] &&
	    nla_get_u16(data[IFLA_MACVLAN_FLAGS]) & ~MACVLAN_FLAG_NOPROMISC)
		return -EINVAL;

1149 1150 1151 1152 1153
	if (data && data[IFLA_MACVLAN_MODE]) {
		switch (nla_get_u32(data[IFLA_MACVLAN_MODE])) {
		case MACVLAN_MODE_PRIVATE:
		case MACVLAN_MODE_VEPA:
		case MACVLAN_MODE_BRIDGE:
1154
		case MACVLAN_MODE_PASSTHRU:
Michael Braun's avatar
Michael Braun committed
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
		case MACVLAN_MODE_SOURCE:
			break;
		default:
			return -EINVAL;
		}
	}

	if (data && data[IFLA_MACVLAN_MACADDR_MODE]) {
		switch (nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE])) {
		case MACVLAN_MACADDR_ADD:
		case MACVLAN_MACADDR_DEL:
		case MACVLAN_MACADDR_FLUSH:
		case MACVLAN_MACADDR_SET:
1168 1169 1170 1171 1172
			break;
		default:
			return -EINVAL;
		}
	}
Michael Braun's avatar
Michael Braun committed
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250

	if (data && data[IFLA_MACVLAN_MACADDR]) {
		if (nla_len(data[IFLA_MACVLAN_MACADDR]) != ETH_ALEN)
			return -EINVAL;

		if (!is_valid_ether_addr(nla_data(data[IFLA_MACVLAN_MACADDR])))
			return -EADDRNOTAVAIL;
	}

	if (data && data[IFLA_MACVLAN_MACADDR_COUNT])
		return -EINVAL;

	return 0;
}

/**
 * reconfigure list of remote source mac address
 * (only for macvlan devices in source mode)
 * Note regarding alignment: all netlink data is aligned to 4 Byte, which
 * suffices for both ether_addr_copy and ether_addr_equal_64bits usage.
 */
static int macvlan_changelink_sources(struct macvlan_dev *vlan, u32 mode,
				      struct nlattr *data[])
{
	char *addr = NULL;
	int ret, rem, len;
	struct nlattr *nla, *head;
	struct macvlan_source_entry *entry;

	if (data[IFLA_MACVLAN_MACADDR])
		addr = nla_data(data[IFLA_MACVLAN_MACADDR]);

	if (mode == MACVLAN_MACADDR_ADD) {
		if (!addr)
			return -EINVAL;

		return macvlan_hash_add_source(vlan, addr);

	} else if (mode == MACVLAN_MACADDR_DEL) {
		if (!addr)
			return -EINVAL;

		entry = macvlan_hash_lookup_source(vlan, addr);
		if (entry) {
			macvlan_hash_del_source(entry);
			vlan->macaddr_count--;
		}
	} else if (mode == MACVLAN_MACADDR_FLUSH) {
		macvlan_flush_sources(vlan->port, vlan);
	} else if (mode == MACVLAN_MACADDR_SET) {
		macvlan_flush_sources(vlan->port, vlan);

		if (addr) {
			ret = macvlan_hash_add_source(vlan, addr);
			if (ret)
				return ret;
		}

		if (!data || !data[IFLA_MACVLAN_MACADDR_DATA])
			return 0;

		head = nla_data(data[IFLA_MACVLAN_MACADDR_DATA]);
		len = nla_len(data[IFLA_MACVLAN_MACADDR_DATA]);

		nla_for_each_attr(nla, head, len, rem) {
			if (nla_type(nla) != IFLA_MACVLAN_MACADDR ||
			    nla_len(nla) != ETH_ALEN)
				continue;

			addr = nla_data(nla);
			ret = macvlan_hash_add_source(vlan, addr);
			if (ret)
				return ret;
		}
	} else {
		return -EINVAL;
	}

Patrick McHardy's avatar
Patrick McHardy committed
1251 1252 1253
	return 0;
}

1254
int macvlan_common_newlink(struct net *src_net, struct net_device *dev,
1255
			   struct nlattr *tb[], struct nlattr *data[])
Patrick McHardy's avatar
Patrick McHardy committed
1256 1257 1258 1259 1260
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct macvlan_port *port;
	struct net_device *lowerdev;
	int err;
Michael Braun's avatar
Michael Braun committed
1261
	int macmode;
Patrick McHardy's avatar
Patrick McHardy committed
1262 1263 1264 1265

	if (!tb[IFLA_LINK])
		return -EINVAL;

1266
	lowerdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
Patrick McHardy's avatar
Patrick McHardy committed
1267 1268 1269
	if (lowerdev == NULL)
		return -ENODEV;

1270
	/* When creating macvlans or macvtaps on top of other macvlans - use
1271
	 * the real device as the lowerdev.
1272
	 */
1273 1274
	if (netif_is_macvlan(lowerdev))
		lowerdev = macvlan_dev_real_dev(lowerdev);
1275

Patrick McHardy's avatar
Patrick McHardy committed
1276 1277 1278 1279 1280 1281
	if (!tb[IFLA_MTU])
		dev->mtu = lowerdev->mtu;
	else if (dev->mtu > lowerdev->mtu)
		return -EINVAL;

	if (!tb[IFLA_ADDRESS])
1282
		eth_hw_addr_random(dev);
Patrick McHardy's avatar
Patrick McHardy committed
1283

1284
	if (!macvlan_port_exists(lowerdev)) {
Patrick McHardy's avatar
Patrick McHardy committed
1285 1286 1287 1288
		err = macvlan_port_create(lowerdev);
		if (err < 0)
			return err;
	}
1289
	port = macvlan_port_get_rtnl(lowerdev);
Patrick McHardy's avatar
Patrick McHardy committed
1290

1291 1292 1293 1294
	/* Only 1 macvlan device can be created in passthru mode */
	if (port->passthru)
		return -EINVAL;

Patrick McHardy's avatar
Patrick McHardy committed
1295 1296 1297
	vlan->lowerdev = lowerdev;
	vlan->dev      = dev;
	vlan->port     = port;
1298
	vlan->set_features = MACVLAN_FEATURES;
1299
	vlan->nest_level = dev_get_nest_level(lowerdev, netif_is_macvlan) + 1;
Patrick McHardy's avatar
Patrick McHardy committed
1300

1301 1302 1303 1304
	vlan->mode     = MACVLAN_MODE_VEPA;
	if (data && data[IFLA_MACVLAN_MODE])
		vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);

1305 1306 1307
	if (data && data[IFLA_MACVLAN_FLAGS])
		vlan->flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);

1308
	if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
1309
		if (port->count)
1310 1311
			return -EINVAL;
		port->passthru = true;
1312
		eth_hw_addr_inherit(dev, lowerdev);
1313 1314
	}

Michael Braun's avatar
Michael Braun committed
1315 1316 1317 1318 1319 1320 1321 1322 1323
	if (data && data[IFLA_MACVLAN_MACADDR_MODE]) {
		if (vlan->mode != MACVLAN_MODE_SOURCE)
			return -EINVAL;
		macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]);
		err = macvlan_changelink_sources(vlan, macmode, data);
		if (err)
			return err;
	}

1324
	port->count += 1;
1325 1326 1327 1328
	err = register_netdevice(dev);
	if (err < 0)
		goto destroy_port;

1329
	dev->priv_flags |= IFF_MACVLAN;
1330 1331
	err = netdev_upper_dev_link(lowerdev, dev);
	if (err)
1332
		goto unregister_netdev;
Patrick McHardy's avatar
Patrick McHardy committed
1333

1334
	list_add_tail_rcu(&vlan->list, &port->vlans);
1335
	netif_stacked_transfer_operstate(lowerdev, dev);
1336

Patrick McHardy's avatar
Patrick McHardy committed
1337
	return 0;
1338

1339 1340
unregister_netdev:
	unregister_netdevice(dev);
1341
destroy_port:
1342 1343
	port->count -= 1;
	if (!port->count)
1344 1345 1346
		macvlan_port_destroy(lowerdev);

	return err;
Patrick McHardy's avatar
Patrick McHardy committed
1347
}
1348
EXPORT_SYMBOL_GPL(macvlan_common_newlink);
Patrick McHardy's avatar
Patrick McHardy committed
1349

1350 1351 1352
static int macvlan_newlink(struct net *src_net, struct net_device *dev,
			   struct nlattr *tb[], struct nlattr *data[])
{
1353
	return macvlan_common_newlink(src_net, dev, tb, data);
1354 1355 1356
}

void macvlan_dellink(struct net_device *dev, struct list_head *head)
Patrick McHardy's avatar
Patrick McHardy committed
1357 1358 1359
{
	struct macvlan_dev *vlan = netdev_priv(dev);

Michael Braun's avatar
Michael Braun committed
1360 1361
	if (vlan->mode == MACVLAN_MODE_SOURCE)
		macvlan_flush_sources(vlan->port, vlan);
1362
	list_del_rcu(&vlan->list);
1363
	unregister_netdevice_queue(dev, head);
1364
	netdev_upper_dev_unlink(vlan->lowerdev, dev);
Patrick McHardy's avatar
Patrick McHardy committed
1365
}
1366
EXPORT_SYMBOL_GPL(macvlan_dellink);
Patrick McHardy's avatar
Patrick McHardy committed
1367

1368 1369 1370 1371
static int macvlan_changelink(struct net_device *dev,
		struct nlattr *tb[], struct nlattr *data[])
{
	struct macvlan_dev *vlan = netdev_priv(dev);
1372 1373
	enum macvlan_mode mode;
	bool set_mode = false;
Michael Braun's avatar
Michael Braun committed
1374 1375
	enum macvlan_macaddr_mode macmode;
	int ret;
1376 1377 1378 1379 1380 1381 1382 1383 1384

	/* Validate mode, but don't set yet: setting flags may fail. */
	if (data && data[IFLA_MACVLAN_MODE]) {
		set_mode = true;
		mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);
		/* Passthrough mode can't be set or cleared dynamically */
		if ((mode == MACVLAN_MODE_PASSTHRU) !=
		    (vlan->mode == MACVLAN_MODE_PASSTHRU))
			return -EINVAL;
Michael Braun's avatar
Michael Braun committed
1385 1386 1387
		if (vlan->mode == MACVLAN_MODE_SOURCE &&
		    vlan->mode != mode)
			macvlan_flush_sources(vlan->port, vlan);
1388
	}
1389

1390 1391 1392
	if (data && data[IFLA_MACVLAN_FLAGS]) {
		__u16 flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);
		bool promisc = (flags ^ vlan->flags) & MACVLAN_FLAG_NOPROMISC;
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
		if (vlan->port->passthru && promisc) {
			int err;

			if (flags & MACVLAN_FLAG_NOPROMISC)
				err = dev_set_promiscuity(vlan->lowerdev, -1);
			else
				err = dev_set_promiscuity(vlan->lowerdev, 1);
			if (err < 0)
				return err;
		}
1403 1404
		vlan->flags = flags;
	}
1405 1406
	if (set_mode)
		vlan->mode = mode;
Michael Braun's avatar
Michael Braun committed
1407 1408 1409 1410 1411 1412 1413 1414
	if (data && data[IFLA_MACVLAN_MACADDR_MODE]) {
		if (vlan->mode != MACVLAN_MODE_SOURCE)
			return -EINVAL;
		macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]);
		ret = macvlan_changelink_sources(vlan, macmode, data);
		if (ret)
			return ret;
	}
1415 1416 1417
	return 0;
}

Michael Braun's avatar
Michael Braun committed
1418 1419 1420 1421 1422 1423 1424 1425
static size_t macvlan_get_size_mac(const struct macvlan_dev *vlan)
{
	if (vlan->macaddr_count == 0)
		return 0;
	return nla_total_size(0) /* IFLA_MACVLAN_MACADDR_DATA */
		+ vlan->macaddr_count * nla_total_size(sizeof(u8) * ETH_ALEN);
}

1426 1427
static size_t macvlan_get_size(const struct net_device *dev)
{
Michael Braun's avatar
Michael Braun committed
1428 1429
	struct macvlan_dev *vlan = netdev_priv(dev);

1430 1431 1432
	return (0
		+ nla_total_size(4) /* IFLA_MACVLAN_MODE */
		+ nla_total_size(2) /* IFLA_MACVLAN_FLAGS */
Michael Braun's avatar
Michael Braun committed
1433 1434
		+ nla_total_size(4) /* IFLA_MACVLAN_MACADDR_COUNT */
		+ macvlan_get_size_mac(vlan) /* IFLA_MACVLAN_MACADDR */
1435
		);
1436 1437
}

Michael Braun's avatar
Michael Braun committed
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
static int macvlan_fill_info_macaddr(struct sk_buff *skb,
				     const struct macvlan_dev *vlan,
				     const int i)
{
	struct hlist_head *h = &vlan->port->vlan_source_hash[i];
	struct macvlan_source_entry *entry;

	hlist_for_each_entry_rcu(entry, h, hlist) {
		if (entry->vlan != vlan)
			continue;
		if (nla_put(skb, IFLA_MACVLAN_MACADDR, ETH_ALEN, entry->addr))
			return 1;
	}
	return 0;
}

1454 1455 1456 1457
static int macvlan_fill_info(struct sk_buff *skb,
				const struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
Michael Braun's avatar
Michael Braun committed
1458 1459
	int i;
	struct nlattr *nest;
1460

1461 1462
	if (nla_put_u32(skb, IFLA_MACVLAN_MODE, vlan->mode))
		goto nla_put_failure;
1463 1464
	if (nla_put_u16(skb, IFLA_MACVLAN_FLAGS, vlan->flags))
		goto nla_put_failure;
Michael Braun's avatar
Michael Braun committed
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
	if (nla_put_u32(skb, IFLA_MACVLAN_MACADDR_COUNT, vlan->macaddr_count))
		goto nla_put_failure;
	if (vlan->macaddr_count > 0) {
		nest = nla_nest_start(skb, IFLA_MACVLAN_MACADDR_DATA);
		if (nest == NULL)
			goto nla_put_failure;

		for (i = 0; i < MACVLAN_HASH_SIZE; i++) {
			if (macvlan_fill_info_macaddr(skb, vlan, i))
				goto nla_put_failure;
		}
		nla_nest_end(skb, nest);
	}
1478 1479 1480 1481 1482 1483 1484
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

static const struct nla_policy macvlan_policy[IFLA_MACVLAN_MAX + 1] = {
1485 1486
	[IFLA_MACVLAN_MODE]  = { .type = NLA_U32 },
	[IFLA_MACVLAN_FLAGS] = { .type = NLA_U16 },
Michael Braun's avatar
Michael Braun committed
1487 1488 1489 1490
	[IFLA_MACVLAN_MACADDR_MODE] = { .type = NLA_U32 },
	[IFLA_MACVLAN_MACADDR] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
	[IFLA_MACVLAN_MACADDR_DATA] = { .type = NLA_NESTED },
	[IFLA_MACVLAN_MACADDR_COUNT] = { .type = NLA_U32 },
1491 1492
};

1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
int macvlan_link_register(struct rtnl_link_ops *ops)
{
	/* common fields */
	ops->priv_size		= sizeof(struct macvlan_dev);
	ops->validate		= macvlan_validate;
	ops->maxtype		= IFLA_MACVLAN_MAX;
	ops->policy		= macvlan_policy;
	ops->changelink		= macvlan_changelink;
	ops->get_size		= macvlan_get_size;
	ops->fill_info		= macvlan_fill_info;

	return rtnl_link_register(ops);
};
EXPORT_SYMBOL_GPL(macvlan_link_register);

1508 1509 1510 1511 1512
static struct net *macvlan_get_link_net(const struct net_device *dev)
{
	return dev_net(macvlan_dev_real_dev(dev));
}

1513
static struct rtnl_link_ops macvlan_link_ops = {
Patrick McHardy's avatar
Patrick McHardy committed
1514
	.kind		= "macvlan",
1515
	.setup		= macvlan_setup,
Patrick McHardy's avatar
Patrick McHardy committed
1516 1517
	.newlink	= macvlan_newlink,
	.dellink	= macvlan_dellink,
1518
	.get_link_net	= macvlan_get_link_net,
Patrick McHardy's avatar
Patrick McHardy committed
1519 1520 1521 1522 1523
};

static int macvlan_device_event(struct notifier_block *unused,
				unsigned long event, void *ptr)
{
1524
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Patrick McHardy's avatar
Patrick McHardy committed
1525 1526
	struct macvlan_dev *vlan, *next;
	struct macvlan_port *port;
1527
	LIST_HEAD(list_kill);
Patrick McHardy's avatar
Patrick McHardy committed
1528

1529
	if (!macvlan_port_exists(dev))
Patrick McHardy's avatar
Patrick McHardy committed
1530 1531
		return NOTIFY_DONE;

1532
	port = macvlan_port_get_rtnl(dev);
1533

Patrick McHardy's avatar
Patrick McHardy committed
1534 1535 1536
	switch (event) {
	case NETDEV_CHANGE:
		list_for_each_entry(vlan, &port->vlans, list)
1537 1538
			netif_stacked_transfer_operstate(vlan->lowerdev,
							 vlan->dev);
Patrick McHardy's avatar
Patrick McHardy committed
1539 1540 1541
		break;
	case NETDEV_FEAT_CHANGE:
		list_for_each_entry(vlan, &port->vlans, list) {
1542
			vlan->dev->gso_max_size = dev->gso_max_size;
1543
			netdev_update_features(vlan->dev);
Patrick McHardy's avatar
Patrick McHardy committed
1544 1545
		}
		break;
1546 1547 1548 1549 1550 1551
	case NETDEV_CHANGEMTU:
		list_for_each_entry(vlan, &port->vlans, list) {
			if (vlan->dev->mtu <= dev->mtu)
				continue;
			dev_set_mtu(vlan->dev, dev->mtu);
		}
1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
		break;
	case NETDEV_CHANGEADDR:
		if (!port->passthru)
			return NOTIFY_DONE;

		vlan = list_first_entry_or_null(&port->vlans,
						struct macvlan_dev,
						list);

		if (macvlan_sync_address(vlan->dev, dev->dev_addr))
			return NOTIFY_BAD;

1564
		break;
Patrick McHardy's avatar
Patrick McHardy committed
1565
	case NETDEV_UNREGISTER:
1566 1567 1568 1569
		/* twiddle thumbs on netns device moves */
		if (dev->reg_state != NETREG_UNREGISTERING)
			break;

Patrick McHardy's avatar
Patrick McHardy committed
1570
		list_for_each_entry_safe(vlan, next, &port->vlans, list)
1571 1572
			vlan->dev->rtnl_link_ops->dellink(vlan->dev, &list_kill);
		unregister_netdevice_many(&list_kill);
Patrick McHardy's avatar
Patrick McHardy committed
1573
		break;
1574 1575 1576
	case NETDEV_PRE_TYPE_CHANGE:
		/* Forbid underlaying device to change its type. */
		return NOTIFY_BAD;
1577 1578 1579 1580 1581 1582 1583

	case NETDEV_NOTIFY_PEERS:
	case NETDEV_BONDING_FAILOVER:
	case NETDEV_RESEND_IGMP:
		/* Propagate to all vlans */
		list_for_each_entry(vlan, &port->vlans, list)
			call_netdevice_notifiers(event, vlan->dev);
Patrick McHardy's avatar
Patrick McHardy committed
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
	}
	return NOTIFY_DONE;
}

static struct notifier_block macvlan_notifier_block __read_mostly = {
	.notifier_call	= macvlan_device_event,
};

static int __init macvlan_init_module(void)
{
	int err;

	register_netdevice_notifier(&macvlan_notifier_block);

1598
	err = macvlan_link_register(&macvlan_link_ops);
Patrick McHardy's avatar
Patrick McHardy committed
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
	if (err < 0)
		goto err1;
	return 0;
err1:
	unregister_netdevice_notifier(&macvlan_notifier_block);
	return err;
}

static void __exit macvlan_cleanup_module(void)
{
	rtnl_link_unregister(&macvlan_link_ops);
	unregister_netdevice_notifier(&macvlan_notifier_block);
}

module_init(macvlan_init_module);
module_exit(macvlan_cleanup_module);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
MODULE_DESCRIPTION("Driver for MAC address based VLANs");
MODULE_ALIAS_RTNL_LINK("macvlan");