projects/linux·blob master · refs

1961 lines · 50.7 KiB

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