macvlan.c 22.2 KB
Newer Older
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>
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>
30 31 32
#include <linux/if_link.h>
#include <linux/if_macvlan.h>
#include <net/rtnetlink.h>
33
#include <net/xfrm.h>
34 35 36 37 38 39 40

#define MACVLAN_HASH_SIZE	(1 << BITS_PER_BYTE)

struct macvlan_port {
	struct net_device	*dev;
	struct hlist_head	vlan_hash[MACVLAN_HASH_SIZE];
	struct list_head	vlans;
41
	struct rcu_head		rcu;
42
	bool 			passthru;
43
	int			count;
44 45
};

46 47
static void macvlan_port_destroy(struct net_device *dev);

48 49 50 51 52
#define macvlan_port_get_rcu(dev) \
	((struct macvlan_port *) rcu_dereference(dev->rx_handler_data))
#define macvlan_port_get(dev) ((struct macvlan_port *) dev->rx_handler_data)
#define macvlan_port_exists(dev) (dev->priv_flags & IFF_MACVLAN_PORT)

53 54 55 56 57 58 59
static struct macvlan_dev *macvlan_hash_lookup(const struct macvlan_port *port,
					       const unsigned char *addr)
{
	struct macvlan_dev *vlan;
	struct hlist_node *n;

	hlist_for_each_entry_rcu(vlan, n, &port->vlan_hash[addr[5]], hlist) {
60
		if (!compare_ether_addr_64bits(vlan->dev->dev_addr, addr))
61 62 63 64 65
			return vlan;
	}
	return NULL;
}

66 67 68 69 70 71 72 73
static void macvlan_hash_add(struct macvlan_dev *vlan)
{
	struct macvlan_port *port = vlan->port;
	const unsigned char *addr = vlan->dev->dev_addr;

	hlist_add_head_rcu(&vlan->hlist, &port->vlan_hash[addr[5]]);
}

74
static void macvlan_hash_del(struct macvlan_dev *vlan, bool sync)
75 76
{
	hlist_del_rcu(&vlan->hlist);
77 78
	if (sync)
		synchronize_rcu();
79 80 81 82 83
}

static void macvlan_hash_change_addr(struct macvlan_dev *vlan,
					const unsigned char *addr)
{
84
	macvlan_hash_del(vlan, true);
85 86 87 88 89 90 91 92 93 94 95 96 97 98
	/* 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.
	 */
99
	if (!compare_ether_addr_64bits(port->dev->dev_addr, addr))
100 101 102 103 104 105 106 107
		return 1;

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

	return 0;
}

108

109 110
static int macvlan_broadcast_one(struct sk_buff *skb,
				 const struct macvlan_dev *vlan,
111
				 const struct ethhdr *eth, bool local)
112
{
113
	struct net_device *dev = vlan->dev;
114 115 116
	if (!skb)
		return NET_RX_DROP;

117
	if (local)
118
		return vlan->forward(dev, skb);
119

120 121 122 123 124 125 126
	skb->dev = dev;
	if (!compare_ether_addr_64bits(eth->h_dest,
				       dev->broadcast))
		skb->pkt_type = PACKET_BROADCAST;
	else
		skb->pkt_type = PACKET_MULTICAST;

127
	return vlan->receive(skb);
128 129
}

130
static void macvlan_broadcast(struct sk_buff *skb,
131 132 133
			      const struct macvlan_port *port,
			      struct net_device *src,
			      enum macvlan_mode mode)
134 135 136 137 138 139
{
	const struct ethhdr *eth = eth_hdr(skb);
	const struct macvlan_dev *vlan;
	struct hlist_node *n;
	struct sk_buff *nskb;
	unsigned int i;
140
	int err;
141

142 143 144
	if (skb->protocol == htons(ETH_P_PAUSE))
		return;

145 146
	for (i = 0; i < MACVLAN_HASH_SIZE; i++) {
		hlist_for_each_entry_rcu(vlan, n, &port->vlan_hash[i], hlist) {
147 148 149
			if (vlan->dev == src || !(vlan->mode & mode))
				continue;

150
			nskb = skb_clone(skb, GFP_ATOMIC);
151
			err = macvlan_broadcast_one(nskb, vlan, eth,
152
					 mode == MACVLAN_MODE_BRIDGE);
153 154
			macvlan_count_rx(vlan, skb->len + ETH_HLEN,
					 err == NET_RX_SUCCESS, 1);
155 156 157 158 159
		}
	}
}

/* called under rcu_read_lock() from netif_receive_skb */
160
static rx_handler_result_t macvlan_handle_frame(struct sk_buff **pskb)
161
{
162
	struct macvlan_port *port;
163
	struct sk_buff *skb = *pskb;
164 165
	const struct ethhdr *eth = eth_hdr(skb);
	const struct macvlan_dev *vlan;
166
	const struct macvlan_dev *src;
167
	struct net_device *dev;
168 169
	unsigned int len = 0;
	int ret = NET_RX_DROP;
170

171
	port = macvlan_port_get_rcu(skb->dev);
172
	if (is_multicast_ether_addr(eth->h_dest)) {
173 174 175
		skb = ip_check_defrag(skb, IP_DEFRAG_MACVLAN);
		if (!skb)
			return RX_HANDLER_CONSUMED;
176
		eth = eth_hdr(skb);
177 178 179 180 181 182
		src = macvlan_hash_lookup(port, eth->h_source);
		if (!src)
			/* frame comes from an external address */
			macvlan_broadcast(skb, port, NULL,
					  MACVLAN_MODE_PRIVATE |
					  MACVLAN_MODE_VEPA    |
183
					  MACVLAN_MODE_PASSTHRU|
184 185 186 187 188 189 190 191 192 193 194 195 196
					  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);
		else if (src->mode == MACVLAN_MODE_BRIDGE)
			/*
			 * flood only to VEPA ports, bridge ports
			 * already saw the frame on the way out.
			 */
			macvlan_broadcast(skb, port, src->dev,
					  MACVLAN_MODE_VEPA);
197 198 199 200 201 202 203
		else {
			/* forward to original port. */
			vlan = src;
			ret = macvlan_broadcast_one(skb, vlan, eth, 0);
			goto out;
		}

204
		return RX_HANDLER_PASS;
205 206
	}

207 208 209 210
	if (port->passthru)
		vlan = list_first_entry(&port->vlans, struct macvlan_dev, list);
	else
		vlan = macvlan_hash_lookup(port, eth->h_dest);
211
	if (vlan == NULL)
212
		return RX_HANDLER_PASS;
213 214 215 216

	dev = vlan->dev;
	if (unlikely(!(dev->flags & IFF_UP))) {
		kfree_skb(skb);
217
		return RX_HANDLER_CONSUMED;
218
	}
219
	len = skb->len + ETH_HLEN;
220
	skb = skb_share_check(skb, GFP_ATOMIC);
221
	if (!skb)
222
		goto out;
223 224 225 226

	skb->dev = dev;
	skb->pkt_type = PACKET_HOST;

227 228 229 230
	ret = vlan->receive(skb);

out:
	macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, 0);
231
	return RX_HANDLER_CONSUMED;
232 233
}

234 235 236 237 238
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;
239
	__u8 ip_summed = skb->ip_summed;
240 241 242

	if (vlan->mode == MACVLAN_MODE_BRIDGE) {
		const struct ethhdr *eth = (void *)skb->data;
243
		skb->ip_summed = CHECKSUM_UNNECESSARY;
244 245 246 247 248 249 250 251 252

		/* 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) {
253
			/* send to lowerdev first for its network taps */
254
			dev_forward_skb(vlan->lowerdev, skb);
255 256 257 258 259 260

			return NET_XMIT_SUCCESS;
		}
	}

xmit_world:
261
	skb->ip_summed = ip_summed;
262
	skb_set_dev(skb, vlan->lowerdev);
263 264 265
	return dev_queue_xmit(skb);
}

266 267
netdev_tx_t macvlan_start_xmit(struct sk_buff *skb,
			       struct net_device *dev)
268 269 270
{
	unsigned int len = skb->len;
	int ret;
E
Eric Dumazet 已提交
271
	const struct macvlan_dev *vlan = netdev_priv(dev);
272

273
	ret = macvlan_queue_xmit(skb, dev);
274
	if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
E
Eric Dumazet 已提交
275
		struct macvlan_pcpu_stats *pcpu_stats;
276

E
Eric Dumazet 已提交
277 278 279 280 281 282 283 284
		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);
	}
285
	return ret;
286
}
287
EXPORT_SYMBOL_GPL(macvlan_start_xmit);
288 289

static int macvlan_hard_header(struct sk_buff *skb, struct net_device *dev,
290 291
			       unsigned short type, const void *daddr,
			       const void *saddr, unsigned len)
292 293 294 295
{
	const struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

296 297
	return dev_hard_header(skb, lowerdev, type, daddr,
			       saddr ? : dev->dev_addr, len);
298 299
}

300 301 302 303 304 305 306 307
static const struct header_ops macvlan_hard_header_ops = {
	.create  	= macvlan_hard_header,
	.rebuild	= eth_rebuild_header,
	.parse		= eth_header_parse,
	.cache		= eth_header_cache,
	.cache_update	= eth_header_cache_update,
};

308 309 310 311 312 313
static int macvlan_open(struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;
	int err;

314 315 316 317 318
	if (vlan->port->passthru) {
		dev_set_promiscuity(lowerdev, 1);
		goto hash_add;
	}

319 320 321 322
	err = -EBUSY;
	if (macvlan_addr_busy(vlan->port, dev->dev_addr))
		goto out;

323
	err = dev_uc_add(lowerdev, dev->dev_addr);
324
	if (err < 0)
325 326 327 328 329 330
		goto out;
	if (dev->flags & IFF_ALLMULTI) {
		err = dev_set_allmulti(lowerdev, 1);
		if (err < 0)
			goto del_unicast;
	}
331 332

hash_add:
333
	macvlan_hash_add(vlan);
334
	return 0;
335 336

del_unicast:
337
	dev_uc_del(lowerdev, dev->dev_addr);
338 339
out:
	return err;
340 341 342 343 344 345 346
}

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

347 348 349 350 351
	if (vlan->port->passthru) {
		dev_set_promiscuity(lowerdev, -1);
		goto hash_del;
	}

352 353 354 355
	dev_mc_unsync(lowerdev, dev);
	if (dev->flags & IFF_ALLMULTI)
		dev_set_allmulti(lowerdev, -1);

356
	dev_uc_del(lowerdev, dev->dev_addr);
357

358
hash_del:
359
	macvlan_hash_del(vlan, !dev->dismantle);
360 361 362
	return 0;
}

363 364 365 366 367 368 369 370 371 372
static int macvlan_set_mac_address(struct net_device *dev, void *p)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;
	struct sockaddr *addr = p;
	int err;

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

373 374 375 376 377 378 379
	if (!(dev->flags & IFF_UP)) {
		/* Just copy in the new address */
		memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
	} else {
		/* Rehash and update the device filters */
		if (macvlan_addr_busy(vlan->port, addr->sa_data))
			return -EBUSY;
380

381
		err = dev_uc_add(lowerdev, addr->sa_data);
382
		if (err)
383
			return err;
384

385
		dev_uc_del(lowerdev, dev->dev_addr);
386 387 388

		macvlan_hash_change_addr(vlan, addr->sa_data);
	}
389 390 391
	return 0;
}

392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
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;

	if (change & IFF_ALLMULTI)
		dev_set_allmulti(lowerdev, dev->flags & IFF_ALLMULTI ? 1 : -1);
}

static void macvlan_set_multicast_list(struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);

	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;
424
static struct lock_class_key macvlan_netdev_addr_lock_key;
425 426 427 428

#define MACVLAN_FEATURES \
	(NETIF_F_SG | NETIF_F_ALL_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
	 NETIF_F_GSO | NETIF_F_TSO | NETIF_F_UFO | NETIF_F_GSO_ROBUST | \
429 430
	 NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \
	 NETIF_F_HW_VLAN_FILTER)
431 432 433 434

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

435 436 437
static void macvlan_set_lockdep_class_one(struct net_device *dev,
					  struct netdev_queue *txq,
					  void *_unused)
438 439 440 441 442 443 444
{
	lockdep_set_class(&txq->_xmit_lock,
			  &macvlan_netdev_xmit_lock_key);
}

static void macvlan_set_lockdep_class(struct net_device *dev)
{
445 446
	lockdep_set_class(&dev->addr_list_lock,
			  &macvlan_netdev_addr_lock_key);
447
	netdev_for_each_tx_queue(dev, macvlan_set_lockdep_class_one, NULL);
448 449
}

450 451 452 453 454 455 456 457
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;
E
Eric Dumazet 已提交
458
	dev->features		|= NETIF_F_LLTX;
459
	dev->gso_max_size	= lowerdev->gso_max_size;
460
	dev->iflink		= lowerdev->ifindex;
461
	dev->hard_header_len	= lowerdev->hard_header_len;
462

463 464
	macvlan_set_lockdep_class(dev);

E
Eric Dumazet 已提交
465 466
	vlan->pcpu_stats = alloc_percpu(struct macvlan_pcpu_stats);
	if (!vlan->pcpu_stats)
467 468
		return -ENOMEM;

469 470 471
	return 0;
}

472 473 474
static void macvlan_uninit(struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
475
	struct macvlan_port *port = vlan->port;
476

E
Eric Dumazet 已提交
477
	free_percpu(vlan->pcpu_stats);
478 479 480 481

	port->count -= 1;
	if (!port->count)
		macvlan_port_destroy(port->dev);
482 483
}

484 485
static struct rtnl_link_stats64 *macvlan_dev_get_stats64(struct net_device *dev,
							 struct rtnl_link_stats64 *stats)
486 487 488
{
	struct macvlan_dev *vlan = netdev_priv(dev);

E
Eric Dumazet 已提交
489 490 491 492
	if (vlan->pcpu_stats) {
		struct macvlan_pcpu_stats *p;
		u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes;
		u32 rx_errors = 0, tx_dropped = 0;
493
		unsigned int start;
494 495 496
		int i;

		for_each_possible_cpu(i) {
E
Eric Dumazet 已提交
497
			p = per_cpu_ptr(vlan->pcpu_stats, i);
498 499 500 501 502
			do {
				start = u64_stats_fetch_begin_bh(&p->syncp);
				rx_packets	= p->rx_packets;
				rx_bytes	= p->rx_bytes;
				rx_multicast	= p->rx_multicast;
E
Eric Dumazet 已提交
503 504
				tx_packets	= p->tx_packets;
				tx_bytes	= p->tx_bytes;
505
			} while (u64_stats_fetch_retry_bh(&p->syncp, start));
E
Eric Dumazet 已提交
506 507 508 509 510 511 512 513 514 515 516

			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;
517
		}
E
Eric Dumazet 已提交
518 519 520
		stats->rx_errors	= rx_errors;
		stats->rx_dropped	= rx_errors;
		stats->tx_dropped	= tx_dropped;
521 522 523 524
	}
	return stats;
}

525
static int macvlan_vlan_rx_add_vid(struct net_device *dev,
526 527 528 529 530
				    unsigned short vid)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

531
	return vlan_vid_add(lowerdev, vid);
532 533
}

534
static int macvlan_vlan_rx_kill_vid(struct net_device *dev,
535 536 537 538 539
				     unsigned short vid)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

540
	vlan_vid_del(lowerdev, vid);
541
	return 0;
542 543
}

544 545 546 547 548 549 550
static void macvlan_ethtool_get_drvinfo(struct net_device *dev,
					struct ethtool_drvinfo *drvinfo)
{
	snprintf(drvinfo->driver, 32, "macvlan");
	snprintf(drvinfo->version, 32, "0.1");
}

551 552 553 554
static int macvlan_ethtool_get_settings(struct net_device *dev,
					struct ethtool_cmd *cmd)
{
	const struct macvlan_dev *vlan = netdev_priv(dev);
555 556

	return __ethtool_get_settings(vlan->lowerdev, cmd);
557 558
}

559 560
static const struct ethtool_ops macvlan_ethtool_ops = {
	.get_link		= ethtool_op_get_link,
561
	.get_settings		= macvlan_ethtool_get_settings,
562 563 564
	.get_drvinfo		= macvlan_ethtool_get_drvinfo,
};

565 566
static const struct net_device_ops macvlan_netdev_ops = {
	.ndo_init		= macvlan_init,
567
	.ndo_uninit		= macvlan_uninit,
568 569
	.ndo_open		= macvlan_open,
	.ndo_stop		= macvlan_stop,
570
	.ndo_start_xmit		= macvlan_start_xmit,
571 572 573
	.ndo_change_mtu		= macvlan_change_mtu,
	.ndo_change_rx_flags	= macvlan_change_rx_flags,
	.ndo_set_mac_address	= macvlan_set_mac_address,
574
	.ndo_set_rx_mode	= macvlan_set_multicast_list,
575
	.ndo_get_stats64	= macvlan_dev_get_stats64,
576
	.ndo_validate_addr	= eth_validate_addr,
577 578
	.ndo_vlan_rx_add_vid	= macvlan_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid	= macvlan_vlan_rx_kill_vid,
579 580
};

581
void macvlan_common_setup(struct net_device *dev)
582 583 584
{
	ether_setup(dev);

585
	dev->priv_flags	       &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
586
	dev->netdev_ops		= &macvlan_netdev_ops;
587
	dev->destructor		= free_netdev;
588
	dev->header_ops		= &macvlan_hard_header_ops,
589
	dev->ethtool_ops	= &macvlan_ethtool_ops;
590 591 592 593 594 595
}
EXPORT_SYMBOL_GPL(macvlan_common_setup);

static void macvlan_setup(struct net_device *dev)
{
	macvlan_common_setup(dev);
596 597 598 599 600 601 602
	dev->tx_queue_len	= 0;
}

static int macvlan_port_create(struct net_device *dev)
{
	struct macvlan_port *port;
	unsigned int i;
603
	int err;
604 605 606 607 608 609 610 611

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

	port = kzalloc(sizeof(*port), GFP_KERNEL);
	if (port == NULL)
		return -ENOMEM;

612
	port->passthru = false;
613 614 615 616
	port->dev = dev;
	INIT_LIST_HEAD(&port->vlans);
	for (i = 0; i < MACVLAN_HASH_SIZE; i++)
		INIT_HLIST_HEAD(&port->vlan_hash[i]);
617

618 619
	err = netdev_rx_handler_register(dev, macvlan_handle_frame, port);
	if (err)
620
		kfree(port);
621 622
	else
		dev->priv_flags |= IFF_MACVLAN_PORT;
623
	return err;
624 625 626 627
}

static void macvlan_port_destroy(struct net_device *dev)
{
628
	struct macvlan_port *port = macvlan_port_get(dev);
629

630
	dev->priv_flags &= ~IFF_MACVLAN_PORT;
631
	netdev_rx_handler_unregister(dev);
632
	kfree_rcu(port, rcu);
633 634 635 636 637 638 639 640 641 642
}

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;
	}
643 644 645 646 647 648

	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:
649
		case MACVLAN_MODE_PASSTHRU:
650 651 652 653 654
			break;
		default:
			return -EINVAL;
		}
	}
655 656 657
	return 0;
}

658 659 660 661 662
int macvlan_common_newlink(struct net *src_net, struct net_device *dev,
			   struct nlattr *tb[], struct nlattr *data[],
			   int (*receive)(struct sk_buff *skb),
			   int (*forward)(struct net_device *dev,
					  struct sk_buff *skb))
663 664 665 666 667 668 669 670 671
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct macvlan_port *port;
	struct net_device *lowerdev;
	int err;

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

672
	lowerdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
673 674 675
	if (lowerdev == NULL)
		return -ENODEV;

676 677
	/* When creating macvlans on top of other macvlans - use
	 * the real device as the lowerdev.
678
	 */
679 680 681 682
	if (lowerdev->rtnl_link_ops == dev->rtnl_link_ops) {
		struct macvlan_dev *lowervlan = netdev_priv(lowerdev);
		lowerdev = lowervlan->lowerdev;
	}
683

684 685 686 687 688 689 690 691
	if (!tb[IFLA_MTU])
		dev->mtu = lowerdev->mtu;
	else if (dev->mtu > lowerdev->mtu)
		return -EINVAL;

	if (!tb[IFLA_ADDRESS])
		random_ether_addr(dev->dev_addr);

692
	if (!macvlan_port_exists(lowerdev)) {
693 694 695 696
		err = macvlan_port_create(lowerdev);
		if (err < 0)
			return err;
	}
697
	port = macvlan_port_get(lowerdev);
698

699 700 701 702
	/* Only 1 macvlan device can be created in passthru mode */
	if (port->passthru)
		return -EINVAL;

703 704 705
	vlan->lowerdev = lowerdev;
	vlan->dev      = dev;
	vlan->port     = port;
706 707
	vlan->receive  = receive;
	vlan->forward  = forward;
708

709 710 711 712
	vlan->mode     = MACVLAN_MODE_VEPA;
	if (data && data[IFLA_MACVLAN_MODE])
		vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);

713
	if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
714
		if (port->count)
715 716 717 718 719
			return -EINVAL;
		port->passthru = true;
		memcpy(dev->dev_addr, lowerdev->dev_addr, ETH_ALEN);
	}

720
	port->count += 1;
721 722
	err = register_netdevice(dev);
	if (err < 0)
723
		goto destroy_port;
724 725

	list_add_tail(&vlan->list, &port->vlans);
726
	netif_stacked_transfer_operstate(lowerdev, dev);
727

728
	return 0;
729 730

destroy_port:
731 732
	port->count -= 1;
	if (!port->count)
733 734 735
		macvlan_port_destroy(lowerdev);

	return err;
736
}
737
EXPORT_SYMBOL_GPL(macvlan_common_newlink);
738

739 740 741 742 743 744 745 746 747
static int macvlan_newlink(struct net *src_net, struct net_device *dev,
			   struct nlattr *tb[], struct nlattr *data[])
{
	return macvlan_common_newlink(src_net, dev, tb, data,
				      netif_rx,
				      dev_forward_skb);
}

void macvlan_dellink(struct net_device *dev, struct list_head *head)
748 749 750 751
{
	struct macvlan_dev *vlan = netdev_priv(dev);

	list_del(&vlan->list);
752
	unregister_netdevice_queue(dev, head);
753
}
754
EXPORT_SYMBOL_GPL(macvlan_dellink);
755

756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
static int macvlan_changelink(struct net_device *dev,
		struct nlattr *tb[], struct nlattr *data[])
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	if (data && data[IFLA_MACVLAN_MODE])
		vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);
	return 0;
}

static size_t macvlan_get_size(const struct net_device *dev)
{
	return nla_total_size(4);
}

static int macvlan_fill_info(struct sk_buff *skb,
				const struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);

	NLA_PUT_U32(skb, IFLA_MACVLAN_MODE, vlan->mode);
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

static const struct nla_policy macvlan_policy[IFLA_MACVLAN_MAX + 1] = {
	[IFLA_MACVLAN_MODE] = { .type = NLA_U32 },
};

786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
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);

static struct rtnl_link_ops macvlan_link_ops = {
802
	.kind		= "macvlan",
803
	.setup		= macvlan_setup,
804 805 806 807 808 809 810 811 812 813
	.newlink	= macvlan_newlink,
	.dellink	= macvlan_dellink,
};

static int macvlan_device_event(struct notifier_block *unused,
				unsigned long event, void *ptr)
{
	struct net_device *dev = ptr;
	struct macvlan_dev *vlan, *next;
	struct macvlan_port *port;
814
	LIST_HEAD(list_kill);
815

816
	if (!macvlan_port_exists(dev))
817 818
		return NOTIFY_DONE;

819 820
	port = macvlan_port_get(dev);

821 822 823
	switch (event) {
	case NETDEV_CHANGE:
		list_for_each_entry(vlan, &port->vlans, list)
824 825
			netif_stacked_transfer_operstate(vlan->lowerdev,
							 vlan->dev);
826 827 828 829
		break;
	case NETDEV_FEAT_CHANGE:
		list_for_each_entry(vlan, &port->vlans, list) {
			vlan->dev->features = dev->features & MACVLAN_FEATURES;
830
			vlan->dev->gso_max_size = dev->gso_max_size;
831 832 833 834
			netdev_features_change(vlan->dev);
		}
		break;
	case NETDEV_UNREGISTER:
835 836 837 838
		/* twiddle thumbs on netns device moves */
		if (dev->reg_state != NETREG_UNREGISTERING)
			break;

839
		list_for_each_entry_safe(vlan, next, &port->vlans, list)
840 841 842
			vlan->dev->rtnl_link_ops->dellink(vlan->dev, &list_kill);
		unregister_netdevice_many(&list_kill);
		list_del(&list_kill);
843
		break;
844 845 846
	case NETDEV_PRE_TYPE_CHANGE:
		/* Forbid underlaying device to change its type. */
		return NOTIFY_BAD;
847 848 849 850 851 852 853 854 855 856 857 858 859 860
	}
	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);

861
	err = macvlan_link_register(&macvlan_link_ops);
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
	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");