macvlan.c 23.8 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 (ether_addr_equal_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 (ether_addr_equal_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
	skb->dev = dev;
121
	if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast))
122 123 124 125
		skb->pkt_type = PACKET_BROADCAST;
	else
		skb->pkt_type = PACKET_MULTICAST;

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

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

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

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

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

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

170
	port = macvlan_port_get_rcu(skb->dev);
171
	if (is_multicast_ether_addr(eth->h_dest)) {
172 173 174
		skb = ip_check_defrag(skb, IP_DEFRAG_MACVLAN);
		if (!skb)
			return RX_HANDLER_CONSUMED;
175
		eth = eth_hdr(skb);
176 177 178 179 180 181
		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    |
182
					  MACVLAN_MODE_PASSTHRU|
183 184 185 186 187 188 189 190 191 192 193 194 195
					  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);
196 197 198 199 200 201 202
		else {
			/* forward to original port. */
			vlan = src;
			ret = macvlan_broadcast_one(skb, vlan, eth, 0);
			goto out;
		}

203
		return RX_HANDLER_PASS;
204 205
	}

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

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

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

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

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

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

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

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

			return NET_XMIT_SUCCESS;
		}
	}

xmit_world:
260
	skb->ip_summed = ip_summed;
261
	skb->dev = vlan->lowerdev;
262 263 264
	return dev_queue_xmit(skb);
}

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

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

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

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

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

299 300 301 302 303 304 305 306
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,
};

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

313
	if (vlan->port->passthru) {
314 315
		if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC))
			dev_set_promiscuity(lowerdev, 1);
316 317 318
		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
	dev_uc_unsync(lowerdev, dev);
	dev_mc_unsync(lowerdev, dev);

350
	if (vlan->port->passthru) {
351 352
		if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC))
			dev_set_promiscuity(lowerdev, -1);
353 354 355
		goto hash_del;
	}

356 357 358
	if (dev->flags & IFF_ALLMULTI)
		dev_set_allmulti(lowerdev, -1);

359
	dev_uc_del(lowerdev, dev->dev_addr);
360

361
hash_del:
362
	macvlan_hash_del(vlan, !dev->dismantle);
363 364 365
	return 0;
}

366 367 368 369 370 371 372 373 374 375
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;

376 377
	if (!(dev->flags & IFF_UP)) {
		/* Just copy in the new address */
378
		dev->addr_assign_type &= ~NET_ADDR_RANDOM;
379 380 381 382 383
		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;
384

385
		err = dev_uc_add(lowerdev, addr->sa_data);
386
		if (err)
387
			return err;
388

389
		dev_uc_del(lowerdev, dev->dev_addr);
390 391 392

		macvlan_hash_change_addr(vlan, addr->sa_data);
	}
393 394 395
	return 0;
}

396 397 398 399 400 401 402 403 404
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);
}

405
static void macvlan_set_mac_lists(struct net_device *dev)
406 407 408
{
	struct macvlan_dev *vlan = netdev_priv(dev);

409
	dev_uc_sync(vlan->lowerdev, dev);
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
	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;
429
static struct lock_class_key macvlan_netdev_addr_lock_key;
430 431 432 433

#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 | \
434 435
	 NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \
	 NETIF_F_HW_VLAN_FILTER)
436 437 438 439

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

440 441 442
static void macvlan_set_lockdep_class_one(struct net_device *dev,
					  struct netdev_queue *txq,
					  void *_unused)
443 444 445 446 447 448 449
{
	lockdep_set_class(&txq->_xmit_lock,
			  &macvlan_netdev_xmit_lock_key);
}

static void macvlan_set_lockdep_class(struct net_device *dev)
{
450 451
	lockdep_set_class(&dev->addr_list_lock,
			  &macvlan_netdev_addr_lock_key);
452
	netdev_for_each_tx_queue(dev, macvlan_set_lockdep_class_one, NULL);
453 454
}

455 456 457 458 459 460 461 462
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 已提交
463
	dev->features		|= NETIF_F_LLTX;
464
	dev->gso_max_size	= lowerdev->gso_max_size;
465
	dev->iflink		= lowerdev->ifindex;
466
	dev->hard_header_len	= lowerdev->hard_header_len;
467

468 469
	macvlan_set_lockdep_class(dev);

E
Eric Dumazet 已提交
470 471
	vlan->pcpu_stats = alloc_percpu(struct macvlan_pcpu_stats);
	if (!vlan->pcpu_stats)
472 473
		return -ENOMEM;

474 475 476
	return 0;
}

477 478 479
static void macvlan_uninit(struct net_device *dev)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
480
	struct macvlan_port *port = vlan->port;
481

E
Eric Dumazet 已提交
482
	free_percpu(vlan->pcpu_stats);
483 484 485 486

	port->count -= 1;
	if (!port->count)
		macvlan_port_destroy(port->dev);
487 488
}

489 490
static struct rtnl_link_stats64 *macvlan_dev_get_stats64(struct net_device *dev,
							 struct rtnl_link_stats64 *stats)
491 492 493
{
	struct macvlan_dev *vlan = netdev_priv(dev);

E
Eric Dumazet 已提交
494 495 496 497
	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;
498
		unsigned int start;
499 500 501
		int i;

		for_each_possible_cpu(i) {
E
Eric Dumazet 已提交
502
			p = per_cpu_ptr(vlan->pcpu_stats, i);
503 504 505 506 507
			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 已提交
508 509
				tx_packets	= p->tx_packets;
				tx_bytes	= p->tx_bytes;
510
			} while (u64_stats_fetch_retry_bh(&p->syncp, start));
E
Eric Dumazet 已提交
511 512 513 514 515 516 517 518 519 520 521

			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;
522
		}
E
Eric Dumazet 已提交
523 524 525
		stats->rx_errors	= rx_errors;
		stats->rx_dropped	= rx_errors;
		stats->tx_dropped	= tx_dropped;
526 527 528 529
	}
	return stats;
}

530
static int macvlan_vlan_rx_add_vid(struct net_device *dev,
531 532 533 534 535
				    unsigned short vid)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

536
	return vlan_vid_add(lowerdev, vid);
537 538
}

539
static int macvlan_vlan_rx_kill_vid(struct net_device *dev,
540 541 542 543 544
				     unsigned short vid)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct net_device *lowerdev = vlan->lowerdev;

545
	vlan_vid_del(lowerdev, vid);
546
	return 0;
547 548
}

549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
static int macvlan_fdb_add(struct ndmsg *ndm,
			   struct net_device *dev,
			   unsigned char *addr,
			   u16 flags)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	int err = -EINVAL;

	if (!vlan->port->passthru)
		return -EOPNOTSUPP;

	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;
}

static int macvlan_fdb_del(struct ndmsg *ndm,
			   struct net_device *dev,
			   unsigned char *addr)
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	int err = -EINVAL;

	if (!vlan->port->passthru)
		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;
}

586 587 588 589 590 591 592
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");
}

593 594 595 596
static int macvlan_ethtool_get_settings(struct net_device *dev,
					struct ethtool_cmd *cmd)
{
	const struct macvlan_dev *vlan = netdev_priv(dev);
597 598

	return __ethtool_get_settings(vlan->lowerdev, cmd);
599 600
}

601 602
static const struct ethtool_ops macvlan_ethtool_ops = {
	.get_link		= ethtool_op_get_link,
603
	.get_settings		= macvlan_ethtool_get_settings,
604 605 606
	.get_drvinfo		= macvlan_ethtool_get_drvinfo,
};

607 608
static const struct net_device_ops macvlan_netdev_ops = {
	.ndo_init		= macvlan_init,
609
	.ndo_uninit		= macvlan_uninit,
610 611
	.ndo_open		= macvlan_open,
	.ndo_stop		= macvlan_stop,
612
	.ndo_start_xmit		= macvlan_start_xmit,
613 614 615
	.ndo_change_mtu		= macvlan_change_mtu,
	.ndo_change_rx_flags	= macvlan_change_rx_flags,
	.ndo_set_mac_address	= macvlan_set_mac_address,
616
	.ndo_set_rx_mode	= macvlan_set_mac_lists,
617
	.ndo_get_stats64	= macvlan_dev_get_stats64,
618
	.ndo_validate_addr	= eth_validate_addr,
619 620
	.ndo_vlan_rx_add_vid	= macvlan_vlan_rx_add_vid,
	.ndo_vlan_rx_kill_vid	= macvlan_vlan_rx_kill_vid,
621 622 623
	.ndo_fdb_add		= macvlan_fdb_add,
	.ndo_fdb_del		= macvlan_fdb_del,
	.ndo_fdb_dump		= ndo_dflt_fdb_dump,
624 625
};

626
void macvlan_common_setup(struct net_device *dev)
627 628 629
{
	ether_setup(dev);

630
	dev->priv_flags	       &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
631
	dev->netdev_ops		= &macvlan_netdev_ops;
632
	dev->destructor		= free_netdev;
633
	dev->header_ops		= &macvlan_hard_header_ops,
634
	dev->ethtool_ops	= &macvlan_ethtool_ops;
635 636 637 638 639 640
}
EXPORT_SYMBOL_GPL(macvlan_common_setup);

static void macvlan_setup(struct net_device *dev)
{
	macvlan_common_setup(dev);
641 642 643 644 645 646 647
	dev->tx_queue_len	= 0;
}

static int macvlan_port_create(struct net_device *dev)
{
	struct macvlan_port *port;
	unsigned int i;
648
	int err;
649 650 651 652 653 654 655 656

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

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

657
	port->passthru = false;
658 659 660 661
	port->dev = dev;
	INIT_LIST_HEAD(&port->vlans);
	for (i = 0; i < MACVLAN_HASH_SIZE; i++)
		INIT_HLIST_HEAD(&port->vlan_hash[i]);
662

663 664
	err = netdev_rx_handler_register(dev, macvlan_handle_frame, port);
	if (err)
665
		kfree(port);
666 667
	else
		dev->priv_flags |= IFF_MACVLAN_PORT;
668
	return err;
669 670 671 672
}

static void macvlan_port_destroy(struct net_device *dev)
{
673
	struct macvlan_port *port = macvlan_port_get(dev);
674

675
	dev->priv_flags &= ~IFF_MACVLAN_PORT;
676
	netdev_rx_handler_unregister(dev);
677
	kfree_rcu(port, rcu);
678 679 680 681 682 683 684 685 686 687
}

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;
	}
688 689 690 691 692 693

	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:
694
		case MACVLAN_MODE_PASSTHRU:
695 696 697 698 699
			break;
		default:
			return -EINVAL;
		}
	}
700 701 702
	return 0;
}

703 704 705 706 707
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))
708 709 710 711 712 713 714 715 716
{
	struct macvlan_dev *vlan = netdev_priv(dev);
	struct macvlan_port *port;
	struct net_device *lowerdev;
	int err;

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

717
	lowerdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
718 719 720
	if (lowerdev == NULL)
		return -ENODEV;

721 722
	/* When creating macvlans on top of other macvlans - use
	 * the real device as the lowerdev.
723
	 */
724 725 726 727
	if (lowerdev->rtnl_link_ops == dev->rtnl_link_ops) {
		struct macvlan_dev *lowervlan = netdev_priv(lowerdev);
		lowerdev = lowervlan->lowerdev;
	}
728

729 730 731 732 733 734
	if (!tb[IFLA_MTU])
		dev->mtu = lowerdev->mtu;
	else if (dev->mtu > lowerdev->mtu)
		return -EINVAL;

	if (!tb[IFLA_ADDRESS])
735
		eth_hw_addr_random(dev);
736

737
	if (!macvlan_port_exists(lowerdev)) {
738 739 740 741
		err = macvlan_port_create(lowerdev);
		if (err < 0)
			return err;
	}
742
	port = macvlan_port_get(lowerdev);
743

744 745 746 747
	/* Only 1 macvlan device can be created in passthru mode */
	if (port->passthru)
		return -EINVAL;

748 749 750
	vlan->lowerdev = lowerdev;
	vlan->dev      = dev;
	vlan->port     = port;
751 752
	vlan->receive  = receive;
	vlan->forward  = forward;
753

754 755 756 757
	vlan->mode     = MACVLAN_MODE_VEPA;
	if (data && data[IFLA_MACVLAN_MODE])
		vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);

758 759 760
	if (data && data[IFLA_MACVLAN_FLAGS])
		vlan->flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);

761
	if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
762
		if (port->count)
763 764 765 766 767
			return -EINVAL;
		port->passthru = true;
		memcpy(dev->dev_addr, lowerdev->dev_addr, ETH_ALEN);
	}

768
	port->count += 1;
769 770
	err = register_netdevice(dev);
	if (err < 0)
771
		goto destroy_port;
772 773

	list_add_tail(&vlan->list, &port->vlans);
774
	netif_stacked_transfer_operstate(lowerdev, dev);
775

776
	return 0;
777 778

destroy_port:
779 780
	port->count -= 1;
	if (!port->count)
781 782 783
		macvlan_port_destroy(lowerdev);

	return err;
784
}
785
EXPORT_SYMBOL_GPL(macvlan_common_newlink);
786

787 788 789 790 791 792 793 794 795
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)
796 797 798 799
{
	struct macvlan_dev *vlan = netdev_priv(dev);

	list_del(&vlan->list);
800
	unregister_netdevice_queue(dev, head);
801
}
802
EXPORT_SYMBOL_GPL(macvlan_dellink);
803

804 805 806 807 808 809
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]);
810 811 812 813 814 815 816 817 818 819
	if (data && data[IFLA_MACVLAN_FLAGS]) {
		__u16 flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);
		bool promisc = (flags ^ vlan->flags) & MACVLAN_FLAG_NOPROMISC;

		if (promisc && (flags & MACVLAN_FLAG_NOPROMISC))
			dev_set_promiscuity(vlan->lowerdev, -1);
		else if (promisc && !(flags & MACVLAN_FLAG_NOPROMISC))
			dev_set_promiscuity(vlan->lowerdev, 1);
		vlan->flags = flags;
	}
820 821 822 823 824 825 826 827 828 829 830 831 832
	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);

833 834
	if (nla_put_u32(skb, IFLA_MACVLAN_MODE, vlan->mode))
		goto nla_put_failure;
835 836
	if (nla_put_u16(skb, IFLA_MACVLAN_FLAGS, vlan->flags))
		goto nla_put_failure;
837 838 839 840 841 842 843
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

static const struct nla_policy macvlan_policy[IFLA_MACVLAN_MAX + 1] = {
844 845
	[IFLA_MACVLAN_MODE]  = { .type = NLA_U32 },
	[IFLA_MACVLAN_FLAGS] = { .type = NLA_U16 },
846 847
};

848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
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 = {
864
	.kind		= "macvlan",
865
	.setup		= macvlan_setup,
866 867 868 869 870 871 872 873 874 875
	.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;
876
	LIST_HEAD(list_kill);
877

878
	if (!macvlan_port_exists(dev))
879 880
		return NOTIFY_DONE;

881 882
	port = macvlan_port_get(dev);

883 884 885
	switch (event) {
	case NETDEV_CHANGE:
		list_for_each_entry(vlan, &port->vlans, list)
886 887
			netif_stacked_transfer_operstate(vlan->lowerdev,
							 vlan->dev);
888 889 890 891
		break;
	case NETDEV_FEAT_CHANGE:
		list_for_each_entry(vlan, &port->vlans, list) {
			vlan->dev->features = dev->features & MACVLAN_FEATURES;
892
			vlan->dev->gso_max_size = dev->gso_max_size;
893 894 895 896
			netdev_features_change(vlan->dev);
		}
		break;
	case NETDEV_UNREGISTER:
897 898 899 900
		/* twiddle thumbs on netns device moves */
		if (dev->reg_state != NETREG_UNREGISTERING)
			break;

901
		list_for_each_entry_safe(vlan, next, &port->vlans, list)
902 903 904
			vlan->dev->rtnl_link_ops->dellink(vlan->dev, &list_kill);
		unregister_netdevice_many(&list_kill);
		list_del(&list_kill);
905
		break;
906 907 908
	case NETDEV_PRE_TYPE_CHANGE:
		/* Forbid underlaying device to change its type. */
		return NOTIFY_BAD;
909 910 911 912 913 914 915 916 917 918 919 920 921 922
	}
	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);

923
	err = macvlan_link_register(&macvlan_link_ops);
924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944
	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");
新手
引导
客服 返回
顶部