12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2b863ceb7SPatrick McHardy /*
3b863ceb7SPatrick McHardy * Copyright (c) 2007 Patrick McHardy <kaber@trash.net>
4b863ceb7SPatrick McHardy *
5b863ceb7SPatrick McHardy * The code this is based on carried the following copyright notice:
6b863ceb7SPatrick McHardy * ---
7b863ceb7SPatrick McHardy * (C) Copyright 2001-2006
8b863ceb7SPatrick McHardy * Alex Zeffertt, Cambridge Broadband Ltd, ajz@cambridgebroadband.com
9b863ceb7SPatrick McHardy * Re-worked by Ben Greear <greearb@candelatech.com>
10b863ceb7SPatrick McHardy * ---
11b863ceb7SPatrick McHardy */
12b863ceb7SPatrick McHardy #include <linux/kernel.h>
13b863ceb7SPatrick McHardy #include <linux/types.h>
14b863ceb7SPatrick McHardy #include <linux/module.h>
15b863ceb7SPatrick McHardy #include <linux/init.h>
16b863ceb7SPatrick McHardy #include <linux/errno.h>
17b863ceb7SPatrick McHardy #include <linux/slab.h>
18b863ceb7SPatrick McHardy #include <linux/string.h>
1982524746SFranck Bui-Huu #include <linux/rculist.h>
20b863ceb7SPatrick McHardy #include <linux/notifier.h>
21b863ceb7SPatrick McHardy #include <linux/netdevice.h>
22b863ceb7SPatrick McHardy #include <linux/etherdevice.h>
23254c0a2bSHangbin Liu #include <linux/net_tstamp.h>
24b863ceb7SPatrick McHardy #include <linux/ethtool.h>
25b863ceb7SPatrick McHardy #include <linux/if_arp.h>
2687002b03SJiri Pirko #include <linux/if_vlan.h>
27b863ceb7SPatrick McHardy #include <linux/if_link.h>
28b863ceb7SPatrick McHardy #include <linux/if_macvlan.h>
29cd431e73SEric Dumazet #include <linux/hash.h>
30412ca155SHerbert Xu #include <linux/workqueue.h>
31b863ceb7SPatrick McHardy #include <net/rtnetlink.h>
32618e1b74SArnd Bergmann #include <net/xfrm.h>
33688cea83Sdingtianhong #include <linux/netpoll.h>
34254c0a2bSHangbin Liu #include <linux/phy.h>
35b863ceb7SPatrick McHardy
3679cf79abSMichael Braun #define MACVLAN_HASH_BITS 8
3779cf79abSMichael Braun #define MACVLAN_HASH_SIZE (1<<MACVLAN_HASH_BITS)
38d4bff72cSThomas Karlsson #define MACVLAN_DEFAULT_BC_QUEUE_LEN 1000
39b863ceb7SPatrick McHardy
4043c2d578SVlad Yasevich #define MACVLAN_F_PASSTHRU 1
4118c8c54dSVlad Yasevich #define MACVLAN_F_ADDRCHANGE 2
4243c2d578SVlad Yasevich
43b863ceb7SPatrick McHardy struct macvlan_port {
44b863ceb7SPatrick McHardy struct net_device *dev;
45b863ceb7SPatrick McHardy struct hlist_head vlan_hash[MACVLAN_HASH_SIZE];
46b863ceb7SPatrick McHardy struct list_head vlans;
47412ca155SHerbert Xu struct sk_buff_head bc_queue;
48412ca155SHerbert Xu struct work_struct bc_work;
49d4bff72cSThomas Karlsson u32 bc_queue_len_used;
50954d1fa1SHerbert Xu int bc_cutoff;
5143c2d578SVlad Yasevich u32 flags;
525e3c516bSDavid S. Miller int count;
5379cf79abSMichael Braun struct hlist_head vlan_source_hash[MACVLAN_HASH_SIZE];
54d45276e7SHerbert Xu DECLARE_BITMAP(bc_filter, MACVLAN_MC_FILTER_SZ);
559c127a01SHerbert Xu DECLARE_BITMAP(mc_filter, MACVLAN_MC_FILTER_SZ);
5618c8c54dSVlad Yasevich unsigned char perm_addr[ETH_ALEN];
5779cf79abSMichael Braun };
5879cf79abSMichael Braun
5979cf79abSMichael Braun struct macvlan_source_entry {
6079cf79abSMichael Braun struct hlist_node hlist;
6179cf79abSMichael Braun struct macvlan_dev *vlan;
6279cf79abSMichael Braun unsigned char addr[6+2] __aligned(sizeof(u16));
6379cf79abSMichael Braun struct rcu_head rcu;
64b863ceb7SPatrick McHardy };
65b863ceb7SPatrick McHardy
66412ca155SHerbert Xu struct macvlan_skb_cb {
67412ca155SHerbert Xu const struct macvlan_dev *src;
68412ca155SHerbert Xu };
69412ca155SHerbert Xu
70412ca155SHerbert Xu #define MACVLAN_SKB_CB(__skb) ((struct macvlan_skb_cb *)&((__skb)->cb[0]))
71412ca155SHerbert Xu
72d5cd9244SEric W. Biederman static void macvlan_port_destroy(struct net_device *dev);
73d4bff72cSThomas Karlsson static void update_port_bc_queue_len(struct macvlan_port *port);
74d5cd9244SEric W. Biederman
macvlan_passthru(const struct macvlan_port * port)7543c2d578SVlad Yasevich static inline bool macvlan_passthru(const struct macvlan_port *port)
7643c2d578SVlad Yasevich {
7743c2d578SVlad Yasevich return port->flags & MACVLAN_F_PASSTHRU;
7843c2d578SVlad Yasevich }
7943c2d578SVlad Yasevich
macvlan_set_passthru(struct macvlan_port * port)8043c2d578SVlad Yasevich static inline void macvlan_set_passthru(struct macvlan_port *port)
8143c2d578SVlad Yasevich {
8243c2d578SVlad Yasevich port->flags |= MACVLAN_F_PASSTHRU;
8343c2d578SVlad Yasevich }
8443c2d578SVlad Yasevich
macvlan_addr_change(const struct macvlan_port * port)8518c8c54dSVlad Yasevich static inline bool macvlan_addr_change(const struct macvlan_port *port)
8618c8c54dSVlad Yasevich {
8718c8c54dSVlad Yasevich return port->flags & MACVLAN_F_ADDRCHANGE;
8818c8c54dSVlad Yasevich }
8918c8c54dSVlad Yasevich
macvlan_set_addr_change(struct macvlan_port * port)9018c8c54dSVlad Yasevich static inline void macvlan_set_addr_change(struct macvlan_port *port)
9118c8c54dSVlad Yasevich {
9218c8c54dSVlad Yasevich port->flags |= MACVLAN_F_ADDRCHANGE;
9318c8c54dSVlad Yasevich }
9418c8c54dSVlad Yasevich
macvlan_clear_addr_change(struct macvlan_port * port)9518c8c54dSVlad Yasevich static inline void macvlan_clear_addr_change(struct macvlan_port *port)
9618c8c54dSVlad Yasevich {
9718c8c54dSVlad Yasevich port->flags &= ~MACVLAN_F_ADDRCHANGE;
9818c8c54dSVlad Yasevich }
9918c8c54dSVlad Yasevich
10079cf79abSMichael Braun /* Hash Ethernet address */
macvlan_eth_hash(const unsigned char * addr)10179cf79abSMichael Braun static u32 macvlan_eth_hash(const unsigned char *addr)
10279cf79abSMichael Braun {
10379cf79abSMichael Braun u64 value = get_unaligned((u64 *)addr);
10479cf79abSMichael Braun
10579cf79abSMichael Braun /* only want 6 bytes */
10679cf79abSMichael Braun #ifdef __BIG_ENDIAN
10779cf79abSMichael Braun value >>= 16;
10879cf79abSMichael Braun #else
10979cf79abSMichael Braun value <<= 16;
11079cf79abSMichael Braun #endif
11179cf79abSMichael Braun return hash_64(value, MACVLAN_HASH_BITS);
11279cf79abSMichael Braun }
11379cf79abSMichael Braun
macvlan_port_get_rcu(const struct net_device * dev)114e052f7e6SEric Dumazet static struct macvlan_port *macvlan_port_get_rcu(const struct net_device *dev)
115e052f7e6SEric Dumazet {
116e052f7e6SEric Dumazet return rcu_dereference(dev->rx_handler_data);
117e052f7e6SEric Dumazet }
118e052f7e6SEric Dumazet
macvlan_port_get_rtnl(const struct net_device * dev)119e052f7e6SEric Dumazet static struct macvlan_port *macvlan_port_get_rtnl(const struct net_device *dev)
120e052f7e6SEric Dumazet {
121e052f7e6SEric Dumazet return rtnl_dereference(dev->rx_handler_data);
122e052f7e6SEric Dumazet }
123e052f7e6SEric Dumazet
macvlan_hash_lookup(const struct macvlan_port * port,const unsigned char * addr)124b863ceb7SPatrick McHardy static struct macvlan_dev *macvlan_hash_lookup(const struct macvlan_port *port,
125b863ceb7SPatrick McHardy const unsigned char *addr)
126b863ceb7SPatrick McHardy {
127b863ceb7SPatrick McHardy struct macvlan_dev *vlan;
12879cf79abSMichael Braun u32 idx = macvlan_eth_hash(addr);
129b863ceb7SPatrick McHardy
13058e64a31SWei Yongjun hlist_for_each_entry_rcu(vlan, &port->vlan_hash[idx], hlist,
13158e64a31SWei Yongjun lockdep_rtnl_is_held()) {
132a6700db1SJoe Perches if (ether_addr_equal_64bits(vlan->dev->dev_addr, addr))
133b863ceb7SPatrick McHardy return vlan;
134b863ceb7SPatrick McHardy }
135b863ceb7SPatrick McHardy return NULL;
136b863ceb7SPatrick McHardy }
137b863ceb7SPatrick McHardy
macvlan_hash_lookup_source(const struct macvlan_dev * vlan,const unsigned char * addr)13879cf79abSMichael Braun static struct macvlan_source_entry *macvlan_hash_lookup_source(
13979cf79abSMichael Braun const struct macvlan_dev *vlan,
14079cf79abSMichael Braun const unsigned char *addr)
14179cf79abSMichael Braun {
14279cf79abSMichael Braun struct macvlan_source_entry *entry;
14379cf79abSMichael Braun u32 idx = macvlan_eth_hash(addr);
14479cf79abSMichael Braun struct hlist_head *h = &vlan->port->vlan_source_hash[idx];
14579cf79abSMichael Braun
1465df1341eSChuang Wang hlist_for_each_entry_rcu(entry, h, hlist, lockdep_rtnl_is_held()) {
14779cf79abSMichael Braun if (ether_addr_equal_64bits(entry->addr, addr) &&
14879cf79abSMichael Braun entry->vlan == vlan)
14979cf79abSMichael Braun return entry;
15079cf79abSMichael Braun }
15179cf79abSMichael Braun return NULL;
15279cf79abSMichael Braun }
15379cf79abSMichael Braun
macvlan_hash_add_source(struct macvlan_dev * vlan,const unsigned char * addr)15479cf79abSMichael Braun static int macvlan_hash_add_source(struct macvlan_dev *vlan,
15579cf79abSMichael Braun const unsigned char *addr)
15679cf79abSMichael Braun {
15779cf79abSMichael Braun struct macvlan_port *port = vlan->port;
15879cf79abSMichael Braun struct macvlan_source_entry *entry;
15979cf79abSMichael Braun struct hlist_head *h;
16079cf79abSMichael Braun
16179cf79abSMichael Braun entry = macvlan_hash_lookup_source(vlan, addr);
16279cf79abSMichael Braun if (entry)
16379cf79abSMichael Braun return 0;
16479cf79abSMichael Braun
16579cf79abSMichael Braun entry = kmalloc(sizeof(*entry), GFP_KERNEL);
16679cf79abSMichael Braun if (!entry)
16779cf79abSMichael Braun return -ENOMEM;
16879cf79abSMichael Braun
16979cf79abSMichael Braun ether_addr_copy(entry->addr, addr);
17079cf79abSMichael Braun entry->vlan = vlan;
17179cf79abSMichael Braun h = &port->vlan_source_hash[macvlan_eth_hash(addr)];
17279cf79abSMichael Braun hlist_add_head_rcu(&entry->hlist, h);
17379cf79abSMichael Braun vlan->macaddr_count++;
17479cf79abSMichael Braun
17579cf79abSMichael Braun return 0;
17679cf79abSMichael Braun }
17779cf79abSMichael Braun
macvlan_hash_add(struct macvlan_dev * vlan)178f9ac30f0SEric Biederman static void macvlan_hash_add(struct macvlan_dev *vlan)
179f9ac30f0SEric Biederman {
180f9ac30f0SEric Biederman struct macvlan_port *port = vlan->port;
181f9ac30f0SEric Biederman const unsigned char *addr = vlan->dev->dev_addr;
18279cf79abSMichael Braun u32 idx = macvlan_eth_hash(addr);
183f9ac30f0SEric Biederman
18479cf79abSMichael Braun hlist_add_head_rcu(&vlan->hlist, &port->vlan_hash[idx]);
18579cf79abSMichael Braun }
18679cf79abSMichael Braun
macvlan_hash_del_source(struct macvlan_source_entry * entry)18779cf79abSMichael Braun static void macvlan_hash_del_source(struct macvlan_source_entry *entry)
18879cf79abSMichael Braun {
18979cf79abSMichael Braun hlist_del_rcu(&entry->hlist);
19079cf79abSMichael Braun kfree_rcu(entry, rcu);
191f9ac30f0SEric Biederman }
192f9ac30f0SEric Biederman
macvlan_hash_del(struct macvlan_dev * vlan,bool sync)193449f4544SEric Dumazet static void macvlan_hash_del(struct macvlan_dev *vlan, bool sync)
194f9ac30f0SEric Biederman {
195f9ac30f0SEric Biederman hlist_del_rcu(&vlan->hlist);
196449f4544SEric Dumazet if (sync)
197f9ac30f0SEric Biederman synchronize_rcu();
198f9ac30f0SEric Biederman }
199f9ac30f0SEric Biederman
macvlan_hash_change_addr(struct macvlan_dev * vlan,const unsigned char * addr)200f9ac30f0SEric Biederman static void macvlan_hash_change_addr(struct macvlan_dev *vlan,
201f9ac30f0SEric Biederman const unsigned char *addr)
202f9ac30f0SEric Biederman {
203449f4544SEric Dumazet macvlan_hash_del(vlan, true);
204f9ac30f0SEric Biederman /* Now that we are unhashed it is safe to change the device
205f9ac30f0SEric Biederman * address without confusing packet delivery.
206f9ac30f0SEric Biederman */
2072f23e5ceSJakub Kicinski eth_hw_addr_set(vlan->dev, addr);
208f9ac30f0SEric Biederman macvlan_hash_add(vlan);
209f9ac30f0SEric Biederman }
210f9ac30f0SEric Biederman
macvlan_addr_busy(const struct macvlan_port * port,const unsigned char * addr)211d94d0254SGao Feng static bool macvlan_addr_busy(const struct macvlan_port *port,
212f9ac30f0SEric Biederman const unsigned char *addr)
213f9ac30f0SEric Biederman {
21418c8c54dSVlad Yasevich /* Test to see if the specified address is
215f9ac30f0SEric Biederman * currently in use by the underlying device or
216f9ac30f0SEric Biederman * another macvlan.
217f9ac30f0SEric Biederman */
21818c8c54dSVlad Yasevich if (!macvlan_passthru(port) && !macvlan_addr_change(port) &&
219e696cda7SVlad Yasevich ether_addr_equal_64bits(port->dev->dev_addr, addr))
220d94d0254SGao Feng return true;
221f9ac30f0SEric Biederman
222f9ac30f0SEric Biederman if (macvlan_hash_lookup(port, addr))
223d94d0254SGao Feng return true;
224f9ac30f0SEric Biederman
225d94d0254SGao Feng return false;
226f9ac30f0SEric Biederman }
227f9ac30f0SEric Biederman
228a1e514c5SArnd Bergmann
macvlan_broadcast_one(struct sk_buff * skb,const struct macvlan_dev * vlan,const struct ethhdr * eth,bool local)229fc0663d6SArnd Bergmann static int macvlan_broadcast_one(struct sk_buff *skb,
230fc0663d6SArnd Bergmann const struct macvlan_dev *vlan,
231618e1b74SArnd Bergmann const struct ethhdr *eth, bool local)
232a1e514c5SArnd Bergmann {
233fc0663d6SArnd Bergmann struct net_device *dev = vlan->dev;
234a1e514c5SArnd Bergmann
235618e1b74SArnd Bergmann if (local)
236412ca155SHerbert Xu return __dev_forward_skb(dev, skb);
237618e1b74SArnd Bergmann
238a1e514c5SArnd Bergmann skb->dev = dev;
239a6700db1SJoe Perches if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast))
240a1e514c5SArnd Bergmann skb->pkt_type = PACKET_BROADCAST;
241a1e514c5SArnd Bergmann else
242a1e514c5SArnd Bergmann skb->pkt_type = PACKET_MULTICAST;
243a1e514c5SArnd Bergmann
244412ca155SHerbert Xu return 0;
245a1e514c5SArnd Bergmann }
246a1e514c5SArnd Bergmann
macvlan_hash_mix(const struct macvlan_dev * vlan)2473807ff58SEric Dumazet static u32 macvlan_hash_mix(const struct macvlan_dev *vlan)
2483807ff58SEric Dumazet {
2493807ff58SEric Dumazet return (u32)(((unsigned long)vlan) >> L1_CACHE_SHIFT);
2503807ff58SEric Dumazet }
2513807ff58SEric Dumazet
2523807ff58SEric Dumazet
mc_hash(const struct macvlan_dev * vlan,const unsigned char * addr)2533807ff58SEric Dumazet static unsigned int mc_hash(const struct macvlan_dev *vlan,
2543807ff58SEric Dumazet const unsigned char *addr)
255cd431e73SEric Dumazet {
256cd431e73SEric Dumazet u32 val = __get_unaligned_cpu32(addr + 2);
257cd431e73SEric Dumazet
2583807ff58SEric Dumazet val ^= macvlan_hash_mix(vlan);
259cd431e73SEric Dumazet return hash_32(val, MACVLAN_MC_FILTER_BITS);
260cd431e73SEric Dumazet }
261cd431e73SEric Dumazet
macvlan_broadcast(struct sk_buff * skb,const struct macvlan_port * port,struct net_device * src,enum macvlan_mode mode)262b863ceb7SPatrick McHardy static void macvlan_broadcast(struct sk_buff *skb,
263618e1b74SArnd Bergmann const struct macvlan_port *port,
264618e1b74SArnd Bergmann struct net_device *src,
265618e1b74SArnd Bergmann enum macvlan_mode mode)
266b863ceb7SPatrick McHardy {
2671712b2ffSEric Dumazet const struct ethhdr *eth = eth_hdr(skb);
268b863ceb7SPatrick McHardy const struct macvlan_dev *vlan;
269b863ceb7SPatrick McHardy struct sk_buff *nskb;
270b863ceb7SPatrick McHardy unsigned int i;
271a1e514c5SArnd Bergmann int err;
2723807ff58SEric Dumazet unsigned int hash;
273b863ceb7SPatrick McHardy
274efbbced3SPatrick McHardy if (skb->protocol == htons(ETH_P_PAUSE))
275efbbced3SPatrick McHardy return;
276efbbced3SPatrick McHardy
277bb23ffa1SChristophe JAILLET hash_for_each_rcu(port->vlan_hash, i, vlan, hlist) {
278618e1b74SArnd Bergmann if (vlan->dev == src || !(vlan->mode & mode))
279618e1b74SArnd Bergmann continue;
280618e1b74SArnd Bergmann
2813807ff58SEric Dumazet hash = mc_hash(vlan, eth->h_dest);
282cd431e73SEric Dumazet if (!test_bit(hash, vlan->mc_filter))
283cd431e73SEric Dumazet continue;
284de9e8f3fSHerbert Xu
285de9e8f3fSHerbert Xu err = NET_RX_DROP;
286b863ceb7SPatrick McHardy nskb = skb_clone(skb, GFP_ATOMIC);
287de9e8f3fSHerbert Xu if (likely(nskb))
288bb23ffa1SChristophe JAILLET err = macvlan_broadcast_one(nskb, vlan, eth,
289412ca155SHerbert Xu mode == MACVLAN_MODE_BRIDGE) ?:
290566214f4SSebastian Andrzej Siewior netif_rx(nskb);
291a1e514c5SArnd Bergmann macvlan_count_rx(vlan, skb->len + ETH_HLEN,
2924c979935Sjbaron@akamai.com err == NET_RX_SUCCESS, true);
293b863ceb7SPatrick McHardy }
294b863ceb7SPatrick McHardy }
295b863ceb7SPatrick McHardy
macvlan_multicast_rx(const struct macvlan_port * port,const struct macvlan_dev * src,struct sk_buff * skb)296d45276e7SHerbert Xu static void macvlan_multicast_rx(const struct macvlan_port *port,
297d45276e7SHerbert Xu const struct macvlan_dev *src,
298d45276e7SHerbert Xu struct sk_buff *skb)
299412ca155SHerbert Xu {
300412ca155SHerbert Xu if (!src)
301412ca155SHerbert Xu /* frame comes from an external address */
302412ca155SHerbert Xu macvlan_broadcast(skb, port, NULL,
303412ca155SHerbert Xu MACVLAN_MODE_PRIVATE |
304412ca155SHerbert Xu MACVLAN_MODE_VEPA |
305412ca155SHerbert Xu MACVLAN_MODE_PASSTHRU|
306412ca155SHerbert Xu MACVLAN_MODE_BRIDGE);
307412ca155SHerbert Xu else if (src->mode == MACVLAN_MODE_VEPA)
308412ca155SHerbert Xu /* flood to everyone except source */
309412ca155SHerbert Xu macvlan_broadcast(skb, port, src->dev,
310412ca155SHerbert Xu MACVLAN_MODE_VEPA |
311412ca155SHerbert Xu MACVLAN_MODE_BRIDGE);
312412ca155SHerbert Xu else
313412ca155SHerbert Xu /*
314412ca155SHerbert Xu * flood only to VEPA ports, bridge ports
315412ca155SHerbert Xu * already saw the frame on the way out.
316412ca155SHerbert Xu */
317412ca155SHerbert Xu macvlan_broadcast(skb, port, src->dev,
318412ca155SHerbert Xu MACVLAN_MODE_VEPA);
319d45276e7SHerbert Xu }
320412ca155SHerbert Xu
macvlan_process_broadcast(struct work_struct * w)321d45276e7SHerbert Xu static void macvlan_process_broadcast(struct work_struct *w)
322d45276e7SHerbert Xu {
323d45276e7SHerbert Xu struct macvlan_port *port = container_of(w, struct macvlan_port,
324d45276e7SHerbert Xu bc_work);
325d45276e7SHerbert Xu struct sk_buff *skb;
326d45276e7SHerbert Xu struct sk_buff_head list;
327d45276e7SHerbert Xu
328d45276e7SHerbert Xu __skb_queue_head_init(&list);
329d45276e7SHerbert Xu
330d45276e7SHerbert Xu spin_lock_bh(&port->bc_queue.lock);
331d45276e7SHerbert Xu skb_queue_splice_tail_init(&port->bc_queue, &list);
332d45276e7SHerbert Xu spin_unlock_bh(&port->bc_queue.lock);
333d45276e7SHerbert Xu
334d45276e7SHerbert Xu while ((skb = __skb_dequeue(&list))) {
335d45276e7SHerbert Xu const struct macvlan_dev *src = MACVLAN_SKB_CB(skb)->src;
336d45276e7SHerbert Xu
337d45276e7SHerbert Xu rcu_read_lock();
338d45276e7SHerbert Xu macvlan_multicast_rx(port, src, skb);
339412ca155SHerbert Xu rcu_read_unlock();
340412ca155SHerbert Xu
341260916dfSHerbert Xu if (src)
342260916dfSHerbert Xu dev_put(src->dev);
343bf97403aSYang Wei consume_skb(skb);
344ce9a4186SMahesh Bandewar
345ce9a4186SMahesh Bandewar cond_resched();
346412ca155SHerbert Xu }
347412ca155SHerbert Xu }
348412ca155SHerbert Xu
macvlan_broadcast_enqueue(struct macvlan_port * port,const struct macvlan_dev * src,struct sk_buff * skb)349412ca155SHerbert Xu static void macvlan_broadcast_enqueue(struct macvlan_port *port,
350260916dfSHerbert Xu const struct macvlan_dev *src,
351412ca155SHerbert Xu struct sk_buff *skb)
352412ca155SHerbert Xu {
353e676f197SHerbert Xu struct sk_buff *nskb;
354412ca155SHerbert Xu int err = -ENOMEM;
355412ca155SHerbert Xu
356e676f197SHerbert Xu nskb = skb_clone(skb, GFP_ATOMIC);
357e676f197SHerbert Xu if (!nskb)
358412ca155SHerbert Xu goto err;
359412ca155SHerbert Xu
360260916dfSHerbert Xu MACVLAN_SKB_CB(nskb)->src = src;
361260916dfSHerbert Xu
362412ca155SHerbert Xu spin_lock(&port->bc_queue.lock);
363d4bff72cSThomas Karlsson if (skb_queue_len(&port->bc_queue) < port->bc_queue_len_used) {
364260916dfSHerbert Xu if (src)
365260916dfSHerbert Xu dev_hold(src->dev);
366e676f197SHerbert Xu __skb_queue_tail(&port->bc_queue, nskb);
367412ca155SHerbert Xu err = 0;
368412ca155SHerbert Xu }
369412ca155SHerbert Xu spin_unlock(&port->bc_queue.lock);
370412ca155SHerbert Xu
3713d6642eaSzhangxiangqian queue_work(system_unbound_wq, &port->bc_work);
3721d7ea556SMenglong Dong
373412ca155SHerbert Xu if (err)
374e676f197SHerbert Xu goto free_nskb;
375412ca155SHerbert Xu
376412ca155SHerbert Xu return;
377412ca155SHerbert Xu
378e676f197SHerbert Xu free_nskb:
379e676f197SHerbert Xu kfree_skb(nskb);
380412ca155SHerbert Xu err:
381625788b5SEric Dumazet dev_core_stats_rx_dropped_inc(skb->dev);
382412ca155SHerbert Xu }
383412ca155SHerbert Xu
macvlan_flush_sources(struct macvlan_port * port,struct macvlan_dev * vlan)38479cf79abSMichael Braun static void macvlan_flush_sources(struct macvlan_port *port,
38579cf79abSMichael Braun struct macvlan_dev *vlan)
38679cf79abSMichael Braun {
387bb23ffa1SChristophe JAILLET struct macvlan_source_entry *entry;
388bb23ffa1SChristophe JAILLET struct hlist_node *next;
38979cf79abSMichael Braun int i;
39079cf79abSMichael Braun
391bb23ffa1SChristophe JAILLET hash_for_each_safe(port->vlan_source_hash, i, next, entry, hlist)
39279cf79abSMichael Braun if (entry->vlan == vlan)
39379cf79abSMichael Braun macvlan_hash_del_source(entry);
394bb23ffa1SChristophe JAILLET
39579cf79abSMichael Braun vlan->macaddr_count = 0;
39679cf79abSMichael Braun }
39779cf79abSMichael Braun
macvlan_forward_source_one(struct sk_buff * skb,struct macvlan_dev * vlan)39879cf79abSMichael Braun static void macvlan_forward_source_one(struct sk_buff *skb,
39979cf79abSMichael Braun struct macvlan_dev *vlan)
40079cf79abSMichael Braun {
40179cf79abSMichael Braun struct sk_buff *nskb;
40279cf79abSMichael Braun struct net_device *dev;
40379cf79abSMichael Braun int len;
40479cf79abSMichael Braun int ret;
40579cf79abSMichael Braun
40679cf79abSMichael Braun dev = vlan->dev;
40779cf79abSMichael Braun if (unlikely(!(dev->flags & IFF_UP)))
40879cf79abSMichael Braun return;
40979cf79abSMichael Braun
41079cf79abSMichael Braun nskb = skb_clone(skb, GFP_ATOMIC);
41179cf79abSMichael Braun if (!nskb)
41279cf79abSMichael Braun return;
41379cf79abSMichael Braun
41479cf79abSMichael Braun len = nskb->len + ETH_HLEN;
41579cf79abSMichael Braun nskb->dev = dev;
416c8c41ea1SAlexander Duyck
417c8c41ea1SAlexander Duyck if (ether_addr_equal_64bits(eth_hdr(skb)->h_dest, dev->dev_addr))
41879cf79abSMichael Braun nskb->pkt_type = PACKET_HOST;
41979cf79abSMichael Braun
420baebdf48SSebastian Andrzej Siewior ret = __netif_rx(nskb);
4214c979935Sjbaron@akamai.com macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false);
42279cf79abSMichael Braun }
42379cf79abSMichael Braun
macvlan_forward_source(struct sk_buff * skb,struct macvlan_port * port,const unsigned char * addr)424427f0c8cSJethro Beekman static bool macvlan_forward_source(struct sk_buff *skb,
42579cf79abSMichael Braun struct macvlan_port *port,
42679cf79abSMichael Braun const unsigned char *addr)
42779cf79abSMichael Braun {
42879cf79abSMichael Braun struct macvlan_source_entry *entry;
42979cf79abSMichael Braun u32 idx = macvlan_eth_hash(addr);
43079cf79abSMichael Braun struct hlist_head *h = &port->vlan_source_hash[idx];
431427f0c8cSJethro Beekman bool consume = false;
43279cf79abSMichael Braun
43379cf79abSMichael Braun hlist_for_each_entry_rcu(entry, h, hlist) {
434427f0c8cSJethro Beekman if (ether_addr_equal_64bits(entry->addr, addr)) {
435427f0c8cSJethro Beekman if (entry->vlan->flags & MACVLAN_FLAG_NODST)
436427f0c8cSJethro Beekman consume = true;
43779cf79abSMichael Braun macvlan_forward_source_one(skb, entry->vlan);
43879cf79abSMichael Braun }
43979cf79abSMichael Braun }
44079cf79abSMichael Braun
441427f0c8cSJethro Beekman return consume;
442427f0c8cSJethro Beekman }
443427f0c8cSJethro Beekman
444b863ceb7SPatrick McHardy /* called under rcu_read_lock() from netif_receive_skb */
macvlan_handle_frame(struct sk_buff ** pskb)4458a4eb573SJiri Pirko static rx_handler_result_t macvlan_handle_frame(struct sk_buff **pskb)
446b863ceb7SPatrick McHardy {
447ab95bfe0SJiri Pirko struct macvlan_port *port;
4488a4eb573SJiri Pirko struct sk_buff *skb = *pskb;
449b863ceb7SPatrick McHardy const struct ethhdr *eth = eth_hdr(skb);
450b863ceb7SPatrick McHardy const struct macvlan_dev *vlan;
451618e1b74SArnd Bergmann const struct macvlan_dev *src;
452b863ceb7SPatrick McHardy struct net_device *dev;
453ba01877fSSridhar Samudrala unsigned int len = 0;
454d1dd9119Sjbaron@akamai.com int ret;
455d1dd9119Sjbaron@akamai.com rx_handler_result_t handle_res;
456b863ceb7SPatrick McHardy
45781f3dc93SAlexander Sverdlin /* Packets from dev_loopback_xmit() do not have L2 header, bail out */
45881f3dc93SAlexander Sverdlin if (unlikely(skb->pkt_type == PACKET_LOOPBACK))
45981f3dc93SAlexander Sverdlin return RX_HANDLER_PASS;
46081f3dc93SAlexander Sverdlin
461a35e2c1bSJiri Pirko port = macvlan_port_get_rcu(skb->dev);
462b863ceb7SPatrick McHardy if (is_multicast_ether_addr(eth->h_dest)) {
4639c127a01SHerbert Xu unsigned int hash;
4649c127a01SHerbert Xu
46519bcf9f2SEric W. Biederman skb = ip_check_defrag(dev_net(skb->dev), skb, IP_DEFRAG_MACVLAN);
466bc416d97SEric Dumazet if (!skb)
467bc416d97SEric Dumazet return RX_HANDLER_CONSUMED;
468e639b8d8SSabrina Dubroca *pskb = skb;
4694ec7ac12SEric Dumazet eth = eth_hdr(skb);
470e16b8598SMartin Willi if (macvlan_forward_source(skb, port, eth->h_source)) {
471e16b8598SMartin Willi kfree_skb(skb);
472427f0c8cSJethro Beekman return RX_HANDLER_CONSUMED;
473e16b8598SMartin Willi }
474618e1b74SArnd Bergmann src = macvlan_hash_lookup(port, eth->h_source);
475412ca155SHerbert Xu if (src && src->mode != MACVLAN_MODE_VEPA &&
476412ca155SHerbert Xu src->mode != MACVLAN_MODE_BRIDGE) {
477729e72a1Sstephen hemminger /* forward to original port. */
478729e72a1Sstephen hemminger vlan = src;
479412ca155SHerbert Xu ret = macvlan_broadcast_one(skb, vlan, eth, 0) ?:
480baebdf48SSebastian Andrzej Siewior __netif_rx(skb);
481d1dd9119Sjbaron@akamai.com handle_res = RX_HANDLER_CONSUMED;
482729e72a1Sstephen hemminger goto out;
483729e72a1Sstephen hemminger }
484729e72a1Sstephen hemminger
4859c127a01SHerbert Xu hash = mc_hash(NULL, eth->h_dest);
486d45276e7SHerbert Xu if (test_bit(hash, port->bc_filter))
487260916dfSHerbert Xu macvlan_broadcast_enqueue(port, src, skb);
488d45276e7SHerbert Xu else if (test_bit(hash, port->mc_filter))
489d45276e7SHerbert Xu macvlan_multicast_rx(port, src, skb);
490412ca155SHerbert Xu
4918a4eb573SJiri Pirko return RX_HANDLER_PASS;
492b863ceb7SPatrick McHardy }
493b863ceb7SPatrick McHardy
494e16b8598SMartin Willi if (macvlan_forward_source(skb, port, eth->h_source)) {
495e16b8598SMartin Willi kfree_skb(skb);
496427f0c8cSJethro Beekman return RX_HANDLER_CONSUMED;
497e16b8598SMartin Willi }
49843c2d578SVlad Yasevich if (macvlan_passthru(port))
499233c7df0SJiri Pirko vlan = list_first_or_null_rcu(&port->vlans,
500233c7df0SJiri Pirko struct macvlan_dev, list);
501eb06acdcSSridhar Samudrala else
502b863ceb7SPatrick McHardy vlan = macvlan_hash_lookup(port, eth->h_dest);
503dd6b9c2cSAlexander Duyck if (!vlan || vlan->mode == MACVLAN_MODE_SOURCE)
5048a4eb573SJiri Pirko return RX_HANDLER_PASS;
505b863ceb7SPatrick McHardy
506b863ceb7SPatrick McHardy dev = vlan->dev;
507b863ceb7SPatrick McHardy if (unlikely(!(dev->flags & IFF_UP))) {
508b863ceb7SPatrick McHardy kfree_skb(skb);
5098a4eb573SJiri Pirko return RX_HANDLER_CONSUMED;
510b863ceb7SPatrick McHardy }
511a1e514c5SArnd Bergmann len = skb->len + ETH_HLEN;
512b863ceb7SPatrick McHardy skb = skb_share_check(skb, GFP_ATOMIC);
513d1dd9119Sjbaron@akamai.com if (!skb) {
514d1dd9119Sjbaron@akamai.com ret = NET_RX_DROP;
515d1dd9119Sjbaron@akamai.com handle_res = RX_HANDLER_CONSUMED;
516ba01877fSSridhar Samudrala goto out;
517d1dd9119Sjbaron@akamai.com }
518b863ceb7SPatrick McHardy
519e639b8d8SSabrina Dubroca *pskb = skb;
520b863ceb7SPatrick McHardy skb->dev = dev;
521b863ceb7SPatrick McHardy skb->pkt_type = PACKET_HOST;
522b863ceb7SPatrick McHardy
523d1dd9119Sjbaron@akamai.com ret = NET_RX_SUCCESS;
524d1dd9119Sjbaron@akamai.com handle_res = RX_HANDLER_ANOTHER;
525ba01877fSSridhar Samudrala out:
5264c979935Sjbaron@akamai.com macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false);
527d1dd9119Sjbaron@akamai.com return handle_res;
528b863ceb7SPatrick McHardy }
529b863ceb7SPatrick McHardy
macvlan_queue_xmit(struct sk_buff * skb,struct net_device * dev)530618e1b74SArnd Bergmann static int macvlan_queue_xmit(struct sk_buff *skb, struct net_device *dev)
531618e1b74SArnd Bergmann {
532618e1b74SArnd Bergmann const struct macvlan_dev *vlan = netdev_priv(dev);
533618e1b74SArnd Bergmann const struct macvlan_port *port = vlan->port;
534618e1b74SArnd Bergmann const struct macvlan_dev *dest;
535618e1b74SArnd Bergmann
536618e1b74SArnd Bergmann if (vlan->mode == MACVLAN_MODE_BRIDGE) {
5371712b2ffSEric Dumazet const struct ethhdr *eth = skb_eth_hdr(skb);
538618e1b74SArnd Bergmann
539618e1b74SArnd Bergmann /* send to other bridge ports directly */
540618e1b74SArnd Bergmann if (is_multicast_ether_addr(eth->h_dest)) {
5411712b2ffSEric Dumazet skb_reset_mac_header(skb);
542618e1b74SArnd Bergmann macvlan_broadcast(skb, port, dev, MACVLAN_MODE_BRIDGE);
543618e1b74SArnd Bergmann goto xmit_world;
544618e1b74SArnd Bergmann }
545618e1b74SArnd Bergmann
546618e1b74SArnd Bergmann dest = macvlan_hash_lookup(port, eth->h_dest);
547618e1b74SArnd Bergmann if (dest && dest->mode == MACVLAN_MODE_BRIDGE) {
548a37dd333SDavid Ward /* send to lowerdev first for its network taps */
549cb2d0f3eSDavid Ward dev_forward_skb(vlan->lowerdev, skb);
550618e1b74SArnd Bergmann
551618e1b74SArnd Bergmann return NET_XMIT_SUCCESS;
552618e1b74SArnd Bergmann }
553618e1b74SArnd Bergmann }
554618e1b74SArnd Bergmann xmit_world:
55559b9997bSDavid S. Miller skb->dev = vlan->lowerdev;
556eadec877SAlexander Duyck return dev_queue_xmit_accel(skb,
557eadec877SAlexander Duyck netdev_get_sb_channel(dev) ? dev : NULL);
558618e1b74SArnd Bergmann }
559618e1b74SArnd Bergmann
macvlan_netpoll_send_skb(struct macvlan_dev * vlan,struct sk_buff * skb)560688cea83Sdingtianhong static inline netdev_tx_t macvlan_netpoll_send_skb(struct macvlan_dev *vlan, struct sk_buff *skb)
561688cea83Sdingtianhong {
562688cea83Sdingtianhong #ifdef CONFIG_NET_POLL_CONTROLLER
563f78ed220SEric Dumazet return netpoll_send_skb(vlan->netpoll, skb);
564688cea83Sdingtianhong #else
565688cea83Sdingtianhong BUG();
566688cea83Sdingtianhong return NETDEV_TX_OK;
567f78ed220SEric Dumazet #endif
568688cea83Sdingtianhong }
569688cea83Sdingtianhong
macvlan_start_xmit(struct sk_buff * skb,struct net_device * dev)5700db901bdSstephen hemminger static netdev_tx_t macvlan_start_xmit(struct sk_buff *skb,
571424efe9cSStephen Hemminger struct net_device *dev)
572b863ceb7SPatrick McHardy {
57381d4e91cSAlexander Duyck struct macvlan_dev *vlan = netdev_priv(dev);
574b863ceb7SPatrick McHardy unsigned int len = skb->len;
575b863ceb7SPatrick McHardy int ret;
576688cea83Sdingtianhong
577688cea83Sdingtianhong if (unlikely(netpoll_tx_running(dev)))
578688cea83Sdingtianhong return macvlan_netpoll_send_skb(vlan, skb);
579b863ceb7SPatrick McHardy
580618e1b74SArnd Bergmann ret = macvlan_queue_xmit(skb, dev);
581a6cc0cfaSJohn Fastabend
5822d6c9ffcSEric Dumazet if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
583cdf3e274SLi RongQing struct vlan_pcpu_stats *pcpu_stats;
5842c114553SEric Dumazet
5858ffab51bSEric Dumazet pcpu_stats = this_cpu_ptr(vlan->pcpu_stats);
5868ffab51bSEric Dumazet u64_stats_update_begin(&pcpu_stats->syncp);
58709cca53cSEric Dumazet u64_stats_inc(&pcpu_stats->tx_packets);
58809cca53cSEric Dumazet u64_stats_add(&pcpu_stats->tx_bytes, len);
5898ffab51bSEric Dumazet u64_stats_update_end(&pcpu_stats->syncp);
5908ffab51bSEric Dumazet } else {
5918ffab51bSEric Dumazet this_cpu_inc(vlan->pcpu_stats->tx_dropped);
5928ffab51bSEric Dumazet }
593cbbef5e1SPatrick McHardy return ret;
594b863ceb7SPatrick McHardy }
595b863ceb7SPatrick McHardy
macvlan_hard_header(struct sk_buff * skb,struct net_device * dev,unsigned short type,const void * daddr,const void * saddr,unsigned len)596b863ceb7SPatrick McHardy static int macvlan_hard_header(struct sk_buff *skb, struct net_device *dev,
5973b04dddeSStephen Hemminger unsigned short type, const void *daddr,
5983b04dddeSStephen Hemminger const void *saddr, unsigned len)
599b863ceb7SPatrick McHardy {
600b863ceb7SPatrick McHardy const struct macvlan_dev *vlan = netdev_priv(dev);
601b863ceb7SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev;
602b863ceb7SPatrick McHardy
6030c4e8581SStephen Hemminger return dev_hard_header(skb, lowerdev, type, daddr,
604b863ceb7SPatrick McHardy saddr ? : dev->dev_addr, len);
605b863ceb7SPatrick McHardy }
606b863ceb7SPatrick McHardy
6073b04dddeSStephen Hemminger static const struct header_ops macvlan_hard_header_ops = {
6083b04dddeSStephen Hemminger .create = macvlan_hard_header,
6093b04dddeSStephen Hemminger .parse = eth_header_parse,
6103b04dddeSStephen Hemminger .cache = eth_header_cache,
6113b04dddeSStephen Hemminger .cache_update = eth_header_cache_update,
612cb297cc5SZhengchao Shao .parse_protocol = eth_header_parse_protocol,
6133b04dddeSStephen Hemminger };
6143b04dddeSStephen Hemminger
macvlan_open(struct net_device * dev)615b863ceb7SPatrick McHardy static int macvlan_open(struct net_device *dev)
616b863ceb7SPatrick McHardy {
617b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev);
618b863ceb7SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev;
619b863ceb7SPatrick McHardy int err;
620b863ceb7SPatrick McHardy
62143c2d578SVlad Yasevich if (macvlan_passthru(vlan->port)) {
62278738141SMichael S. Tsirkin if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC)) {
62378738141SMichael S. Tsirkin err = dev_set_promiscuity(lowerdev, 1);
62478738141SMichael S. Tsirkin if (err < 0)
62578738141SMichael S. Tsirkin goto out;
62678738141SMichael S. Tsirkin }
627eb06acdcSSridhar Samudrala goto hash_add;
628eb06acdcSSridhar Samudrala }
629eb06acdcSSridhar Samudrala
63059f997b0SMatteo Croce err = -EADDRINUSE;
6317d775f63SAlexander Duyck if (macvlan_addr_busy(vlan->port, dev->dev_addr))
6327d775f63SAlexander Duyck goto out;
6337d775f63SAlexander Duyck
6347d775f63SAlexander Duyck /* Attempt to populate accel_priv which is used to offload the L2
6357d775f63SAlexander Duyck * forwarding requests for unicast packets.
6367d775f63SAlexander Duyck */
63781d4e91cSAlexander Duyck if (lowerdev->features & NETIF_F_HW_L2FW_DOFFLOAD)
6387d775f63SAlexander Duyck vlan->accel_priv =
639a6cc0cfaSJohn Fastabend lowerdev->netdev_ops->ndo_dfwd_add_station(lowerdev, dev);
640a6cc0cfaSJohn Fastabend
64181d4e91cSAlexander Duyck /* If earlier attempt to offload failed, or accel_priv is not
64281d4e91cSAlexander Duyck * populated we must add the unicast address to the lower device.
643a6cc0cfaSJohn Fastabend */
64481d4e91cSAlexander Duyck if (IS_ERR_OR_NULL(vlan->accel_priv)) {
6457d775f63SAlexander Duyck vlan->accel_priv = NULL;
646a748ee24SJiri Pirko err = dev_uc_add(lowerdev, dev->dev_addr);
647b863ceb7SPatrick McHardy if (err < 0)
648b89fb7daSWang Chen goto out;
64981d4e91cSAlexander Duyck }
65081d4e91cSAlexander Duyck
651b89fb7daSWang Chen if (dev->flags & IFF_ALLMULTI) {
652b89fb7daSWang Chen err = dev_set_allmulti(lowerdev, 1);
653b89fb7daSWang Chen if (err < 0)
654b89fb7daSWang Chen goto del_unicast;
655b89fb7daSWang Chen }
656eb06acdcSSridhar Samudrala
657efdbd2b3SVlad Yasevich if (dev->flags & IFF_PROMISC) {
658efdbd2b3SVlad Yasevich err = dev_set_promiscuity(lowerdev, 1);
659efdbd2b3SVlad Yasevich if (err < 0)
660efdbd2b3SVlad Yasevich goto clear_multi;
661efdbd2b3SVlad Yasevich }
662efdbd2b3SVlad Yasevich
663eb06acdcSSridhar Samudrala hash_add:
664f9ac30f0SEric Biederman macvlan_hash_add(vlan);
665b863ceb7SPatrick McHardy return 0;
666b89fb7daSWang Chen
667efdbd2b3SVlad Yasevich clear_multi:
668c3891fa2SGao Feng if (dev->flags & IFF_ALLMULTI)
669efdbd2b3SVlad Yasevich dev_set_allmulti(lowerdev, -1);
670b89fb7daSWang Chen del_unicast:
6717d775f63SAlexander Duyck if (vlan->accel_priv) {
672a6cc0cfaSJohn Fastabend lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev,
6737d775f63SAlexander Duyck vlan->accel_priv);
6747d775f63SAlexander Duyck vlan->accel_priv = NULL;
67581d4e91cSAlexander Duyck } else {
67681d4e91cSAlexander Duyck dev_uc_del(lowerdev, dev->dev_addr);
677a6cc0cfaSJohn Fastabend }
67881d4e91cSAlexander Duyck out:
679b89fb7daSWang Chen return err;
680b863ceb7SPatrick McHardy }
681b863ceb7SPatrick McHardy
macvlan_stop(struct net_device * dev)682b863ceb7SPatrick McHardy static int macvlan_stop(struct net_device *dev)
683b863ceb7SPatrick McHardy {
684b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev);
685b863ceb7SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev;
686b863ceb7SPatrick McHardy
6877d775f63SAlexander Duyck if (vlan->accel_priv) {
688a6cc0cfaSJohn Fastabend lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev,
6897d775f63SAlexander Duyck vlan->accel_priv);
6907d775f63SAlexander Duyck vlan->accel_priv = NULL;
691a6cc0cfaSJohn Fastabend }
692a6cc0cfaSJohn Fastabend
693df8ef8f3SJohn Fastabend dev_uc_unsync(lowerdev, dev);
694df8ef8f3SJohn Fastabend dev_mc_unsync(lowerdev, dev);
695df8ef8f3SJohn Fastabend
69643c2d578SVlad Yasevich if (macvlan_passthru(vlan->port)) {
697df8ef8f3SJohn Fastabend if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC))
698eb06acdcSSridhar Samudrala dev_set_promiscuity(lowerdev, -1);
699eb06acdcSSridhar Samudrala goto hash_del;
700eb06acdcSSridhar Samudrala }
701eb06acdcSSridhar Samudrala
702b863ceb7SPatrick McHardy if (dev->flags & IFF_ALLMULTI)
703b863ceb7SPatrick McHardy dev_set_allmulti(lowerdev, -1);
704b863ceb7SPatrick McHardy
705efdbd2b3SVlad Yasevich if (dev->flags & IFF_PROMISC)
706efdbd2b3SVlad Yasevich dev_set_promiscuity(lowerdev, -1);
707efdbd2b3SVlad Yasevich
708a748ee24SJiri Pirko dev_uc_del(lowerdev, dev->dev_addr);
709b863ceb7SPatrick McHardy
710eb06acdcSSridhar Samudrala hash_del:
711449f4544SEric Dumazet macvlan_hash_del(vlan, !dev->dismantle);
712b863ceb7SPatrick McHardy return 0;
713b863ceb7SPatrick McHardy }
714b863ceb7SPatrick McHardy
macvlan_sync_address(struct net_device * dev,const unsigned char * addr)7158bc7823eSJakub Kicinski static int macvlan_sync_address(struct net_device *dev,
7168bc7823eSJakub Kicinski const unsigned char *addr)
717ad5d20a6SPatrick McHardy {
718ad5d20a6SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev);
719ad5d20a6SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev;
72018c8c54dSVlad Yasevich struct macvlan_port *port = vlan->port;
721ad5d20a6SPatrick McHardy int err;
722ad5d20a6SPatrick McHardy
723f9ac30f0SEric Biederman if (!(dev->flags & IFF_UP)) {
724f9ac30f0SEric Biederman /* Just copy in the new address */
725e35b8d7dSJakub Kicinski eth_hw_addr_set(dev, addr);
726f9ac30f0SEric Biederman } else {
727f9ac30f0SEric Biederman /* Rehash and update the device filters */
728e289fd28Sdingtianhong if (macvlan_addr_busy(vlan->port, addr))
72959f997b0SMatteo Croce return -EADDRINUSE;
730ad5d20a6SPatrick McHardy
73118c8c54dSVlad Yasevich if (!macvlan_passthru(port)) {
732e289fd28Sdingtianhong err = dev_uc_add(lowerdev, addr);
733ccffad25SJiri Pirko if (err)
734ad5d20a6SPatrick McHardy return err;
735f9ac30f0SEric Biederman
736a748ee24SJiri Pirko dev_uc_del(lowerdev, dev->dev_addr);
737e289fd28Sdingtianhong }
738ad5d20a6SPatrick McHardy
739e289fd28Sdingtianhong macvlan_hash_change_addr(vlan, addr);
740f9ac30f0SEric Biederman }
74118c8c54dSVlad Yasevich if (macvlan_passthru(port) && !macvlan_addr_change(port)) {
74218c8c54dSVlad Yasevich /* Since addr_change isn't set, we are here due to lower
74318c8c54dSVlad Yasevich * device change. Save the lower-dev address so we can
74418c8c54dSVlad Yasevich * restore it later.
74518c8c54dSVlad Yasevich */
74618c8c54dSVlad Yasevich ether_addr_copy(vlan->port->perm_addr,
74718c8c54dSVlad Yasevich lowerdev->dev_addr);
74818c8c54dSVlad Yasevich }
74918c8c54dSVlad Yasevich macvlan_clear_addr_change(port);
750ad5d20a6SPatrick McHardy return 0;
751ad5d20a6SPatrick McHardy }
752ad5d20a6SPatrick McHardy
macvlan_set_mac_address(struct net_device * dev,void * p)753e289fd28Sdingtianhong static int macvlan_set_mac_address(struct net_device *dev, void *p)
754e289fd28Sdingtianhong {
755e289fd28Sdingtianhong struct macvlan_dev *vlan = netdev_priv(dev);
756e289fd28Sdingtianhong struct sockaddr *addr = p;
757e289fd28Sdingtianhong
758e289fd28Sdingtianhong if (!is_valid_ether_addr(addr->sa_data))
759e289fd28Sdingtianhong return -EADDRNOTAVAIL;
760e289fd28Sdingtianhong
761e26f43faSVlad Yasevich /* If the addresses are the same, this is a no-op */
762e26f43faSVlad Yasevich if (ether_addr_equal(dev->dev_addr, addr->sa_data))
763e26f43faSVlad Yasevich return 0;
764e26f43faSVlad Yasevich
765e289fd28Sdingtianhong if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
76618c8c54dSVlad Yasevich macvlan_set_addr_change(vlan->port);
7673a37a963SPetr Machata return dev_set_mac_address(vlan->lowerdev, addr, NULL);
768e289fd28Sdingtianhong }
769e289fd28Sdingtianhong
77059f997b0SMatteo Croce if (macvlan_addr_busy(vlan->port, addr->sa_data))
77159f997b0SMatteo Croce return -EADDRINUSE;
77259f997b0SMatteo Croce
773e289fd28Sdingtianhong return macvlan_sync_address(dev, addr->sa_data);
774e289fd28Sdingtianhong }
775e289fd28Sdingtianhong
macvlan_change_rx_flags(struct net_device * dev,int change)776b863ceb7SPatrick McHardy static void macvlan_change_rx_flags(struct net_device *dev, int change)
777b863ceb7SPatrick McHardy {
778b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev);
779b863ceb7SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev;
780b863ceb7SPatrick McHardy
781bbeb0eadSPeter Christensen if (dev->flags & IFF_UP) {
782b863ceb7SPatrick McHardy if (change & IFF_ALLMULTI)
783b863ceb7SPatrick McHardy dev_set_allmulti(lowerdev, dev->flags & IFF_ALLMULTI ? 1 : -1);
7847e1caeacSVlad Buslov if (!macvlan_passthru(vlan->port) && change & IFF_PROMISC)
785efdbd2b3SVlad Yasevich dev_set_promiscuity(lowerdev,
786efdbd2b3SVlad Yasevich dev->flags & IFF_PROMISC ? 1 : -1);
787efdbd2b3SVlad Yasevich
788b863ceb7SPatrick McHardy }
789bbeb0eadSPeter Christensen }
790b863ceb7SPatrick McHardy
macvlan_compute_filter(unsigned long * mc_filter,struct net_device * dev,struct macvlan_dev * vlan,int cutoff)7919c127a01SHerbert Xu static void macvlan_compute_filter(unsigned long *mc_filter,
7929c127a01SHerbert Xu struct net_device *dev,
793d45276e7SHerbert Xu struct macvlan_dev *vlan, int cutoff)
794b863ceb7SPatrick McHardy {
795cd431e73SEric Dumazet if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
7969c127a01SHerbert Xu bitmap_fill(mc_filter, MACVLAN_MC_FILTER_SZ);
797cd431e73SEric Dumazet } else {
798cd431e73SEric Dumazet DECLARE_BITMAP(filter, MACVLAN_MC_FILTER_SZ);
799d45276e7SHerbert Xu struct netdev_hw_addr *ha;
800cd431e73SEric Dumazet
801cd431e73SEric Dumazet bitmap_zero(filter, MACVLAN_MC_FILTER_SZ);
802cd431e73SEric Dumazet netdev_for_each_mc_addr(ha, dev) {
803ae63ad9bSHerbert Xu if (!vlan && ha->synced <= cutoff)
804d45276e7SHerbert Xu continue;
805d45276e7SHerbert Xu
8063807ff58SEric Dumazet __set_bit(mc_hash(vlan, ha->addr), filter);
807cd431e73SEric Dumazet }
808d5270430SEric Dumazet
8093807ff58SEric Dumazet __set_bit(mc_hash(vlan, dev->broadcast), filter);
810d5270430SEric Dumazet
8119c127a01SHerbert Xu bitmap_copy(mc_filter, filter, MACVLAN_MC_FILTER_SZ);
812cd431e73SEric Dumazet }
8139c127a01SHerbert Xu }
8149c127a01SHerbert Xu
macvlan_recompute_bc_filter(struct macvlan_dev * vlan)815954d1fa1SHerbert Xu static void macvlan_recompute_bc_filter(struct macvlan_dev *vlan)
816954d1fa1SHerbert Xu {
817ae63ad9bSHerbert Xu if (vlan->port->bc_cutoff < 0) {
818ae63ad9bSHerbert Xu bitmap_zero(vlan->port->bc_filter, MACVLAN_MC_FILTER_SZ);
819ae63ad9bSHerbert Xu return;
820ae63ad9bSHerbert Xu }
821ae63ad9bSHerbert Xu
822954d1fa1SHerbert Xu macvlan_compute_filter(vlan->port->bc_filter, vlan->lowerdev, NULL,
823954d1fa1SHerbert Xu vlan->port->bc_cutoff);
824954d1fa1SHerbert Xu }
825954d1fa1SHerbert Xu
macvlan_set_mac_lists(struct net_device * dev)8269c127a01SHerbert Xu static void macvlan_set_mac_lists(struct net_device *dev)
8279c127a01SHerbert Xu {
8289c127a01SHerbert Xu struct macvlan_dev *vlan = netdev_priv(dev);
8299c127a01SHerbert Xu
830d45276e7SHerbert Xu macvlan_compute_filter(vlan->mc_filter, dev, vlan, 0);
8319c127a01SHerbert Xu
832df8ef8f3SJohn Fastabend dev_uc_sync(vlan->lowerdev, dev);
833b863ceb7SPatrick McHardy dev_mc_sync(vlan->lowerdev, dev);
8349c127a01SHerbert Xu
8359c127a01SHerbert Xu /* This is slightly inaccurate as we're including the subscription
8369c127a01SHerbert Xu * list of vlan->lowerdev too.
8379c127a01SHerbert Xu *
8389c127a01SHerbert Xu * Bug alert: This only works if everyone has the same broadcast
8399c127a01SHerbert Xu * address as lowerdev. As soon as someone changes theirs this
8409c127a01SHerbert Xu * will break.
8419c127a01SHerbert Xu *
8429c127a01SHerbert Xu * However, this is already broken as when you change your broadcast
8439c127a01SHerbert Xu * address we don't get called.
8449c127a01SHerbert Xu *
8459c127a01SHerbert Xu * The solution is to maintain a list of broadcast addresses like
8469c127a01SHerbert Xu * we do for uc/mc, if you care.
8479c127a01SHerbert Xu */
848d45276e7SHerbert Xu macvlan_compute_filter(vlan->port->mc_filter, vlan->lowerdev, NULL,
849d45276e7SHerbert Xu 0);
850954d1fa1SHerbert Xu macvlan_recompute_bc_filter(vlan);
851954d1fa1SHerbert Xu }
852954d1fa1SHerbert Xu
update_port_bc_cutoff(struct macvlan_dev * vlan,int cutoff)853954d1fa1SHerbert Xu static void update_port_bc_cutoff(struct macvlan_dev *vlan, int cutoff)
854954d1fa1SHerbert Xu {
855954d1fa1SHerbert Xu if (vlan->port->bc_cutoff == cutoff)
856954d1fa1SHerbert Xu return;
857954d1fa1SHerbert Xu
858954d1fa1SHerbert Xu vlan->port->bc_cutoff = cutoff;
859954d1fa1SHerbert Xu macvlan_recompute_bc_filter(vlan);
860b863ceb7SPatrick McHardy }
861b863ceb7SPatrick McHardy
macvlan_change_mtu(struct net_device * dev,int new_mtu)862b863ceb7SPatrick McHardy static int macvlan_change_mtu(struct net_device *dev, int new_mtu)
863b863ceb7SPatrick McHardy {
864b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev);
865b863ceb7SPatrick McHardy
86691572088SJarod Wilson if (vlan->lowerdev->mtu < new_mtu)
867b863ceb7SPatrick McHardy return -EINVAL;
8681eb2cdedSEric Dumazet WRITE_ONCE(dev->mtu, new_mtu);
869b863ceb7SPatrick McHardy return 0;
870b863ceb7SPatrick McHardy }
871b863ceb7SPatrick McHardy
macvlan_hwtstamp_get(struct net_device * dev,struct kernel_hwtstamp_config * cfg)8720bca3f7fSMaxim Georgiev static int macvlan_hwtstamp_get(struct net_device *dev,
8730bca3f7fSMaxim Georgiev struct kernel_hwtstamp_config *cfg)
874254c0a2bSHangbin Liu {
875254c0a2bSHangbin Liu struct net_device *real_dev = macvlan_dev_real_dev(dev);
876254c0a2bSHangbin Liu
8770bca3f7fSMaxim Georgiev return generic_hwtstamp_get_lower(real_dev, cfg);
878254c0a2bSHangbin Liu }
879254c0a2bSHangbin Liu
macvlan_hwtstamp_set(struct net_device * dev,struct kernel_hwtstamp_config * cfg,struct netlink_ext_ack * extack)8800bca3f7fSMaxim Georgiev static int macvlan_hwtstamp_set(struct net_device *dev,
8810bca3f7fSMaxim Georgiev struct kernel_hwtstamp_config *cfg,
8820bca3f7fSMaxim Georgiev struct netlink_ext_ack *extack)
8830bca3f7fSMaxim Georgiev {
8840bca3f7fSMaxim Georgiev struct net_device *real_dev = macvlan_dev_real_dev(dev);
885254c0a2bSHangbin Liu
8860bca3f7fSMaxim Georgiev if (!net_eq(dev_net(dev), &init_net))
8870bca3f7fSMaxim Georgiev return -EOPNOTSUPP;
8880bca3f7fSMaxim Georgiev
8890bca3f7fSMaxim Georgiev return generic_hwtstamp_set_lower(real_dev, cfg, extack);
890254c0a2bSHangbin Liu }
891254c0a2bSHangbin Liu
892b863ceb7SPatrick McHardy /*
893b863ceb7SPatrick McHardy * macvlan network devices have devices nesting below it and are a special
894b863ceb7SPatrick McHardy * "super class" of normal network devices; split their locks off into a
895b863ceb7SPatrick McHardy * separate class since they always nest.
896b863ceb7SPatrick McHardy */
897845e0ebbSCong Wang static struct lock_class_key macvlan_netdev_addr_lock_key;
898845e0ebbSCong Wang
89970957eaeSVlad Yasevich #define ALWAYS_ON_OFFLOADS \
90070957eaeSVlad Yasevich (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_GSO_SOFTWARE | \
901f21e5077SDimitris Michailidis NETIF_F_GSO_ROBUST | NETIF_F_GSO_ENCAP_ALL)
9028b4703e9SVlad Yasevich
903*00d066a4SAlexander Lobakin #define ALWAYS_ON_FEATURES ALWAYS_ON_OFFLOADS
90470957eaeSVlad Yasevich
905b863ceb7SPatrick McHardy #define MACVLAN_FEATURES \
906a188222bSTom Herbert (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \
907fb652fdfSDavid S. Miller NETIF_F_GSO | NETIF_F_TSO | NETIF_F_LRO | \
9088d13e670SJohn Fastabend NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \
90928d2b136SPatrick McHardy NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)
910b863ceb7SPatrick McHardy
911b863ceb7SPatrick McHardy #define MACVLAN_STATE_MASK \
912b863ceb7SPatrick McHardy ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT))
913b863ceb7SPatrick McHardy
macvlan_set_lockdep_class(struct net_device * dev)914845e0ebbSCong Wang static void macvlan_set_lockdep_class(struct net_device *dev)
915845e0ebbSCong Wang {
916845e0ebbSCong Wang netdev_lockdep_set_classes(dev);
917be74294fSCong Wang lockdep_set_class(&dev->addr_list_lock,
918be74294fSCong Wang &macvlan_netdev_addr_lock_key);
919845e0ebbSCong Wang }
920845e0ebbSCong Wang
macvlan_init(struct net_device * dev)921b863ceb7SPatrick McHardy static int macvlan_init(struct net_device *dev)
922b863ceb7SPatrick McHardy {
923b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev);
924291ac684SZiyang Xuan struct net_device *lowerdev = vlan->lowerdev;
92530837960SFrancesco Ruggeri struct macvlan_port *port = vlan->port;
926b863ceb7SPatrick McHardy
927b863ceb7SPatrick McHardy dev->state = (dev->state & ~MACVLAN_STATE_MASK) |
928b863ceb7SPatrick McHardy (lowerdev->state & MACVLAN_STATE_MASK);
929b863ceb7SPatrick McHardy dev->features = lowerdev->features & MACVLAN_FEATURES;
9308b4703e9SVlad Yasevich dev->features |= ALWAYS_ON_FEATURES;
93162dbe830SMichal Kubeček dev->hw_features |= NETIF_F_LRO;
932081e83a7SVlad Yasevich dev->vlan_features = lowerdev->vlan_features & MACVLAN_FEATURES;
93370957eaeSVlad Yasevich dev->vlan_features |= ALWAYS_ON_OFFLOADS;
934f21e5077SDimitris Michailidis dev->hw_enc_features |= dev->features;
935*00d066a4SAlexander Lobakin dev->lltx = true;
9366df6398fSJakub Kicinski netif_inherit_tso_max(dev, lowerdev);
937ef5c8996Ssg.tweak@gmail.com dev->hard_header_len = lowerdev->hard_header_len;
938845e0ebbSCong Wang macvlan_set_lockdep_class(dev);
9391a33e10eSCong Wang
9401c213bd2SWANG Cong vlan->pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats);
9418ffab51bSEric Dumazet if (!vlan->pcpu_stats)
942fccaf710SEric Dumazet return -ENOMEM;
943fccaf710SEric Dumazet
94430837960SFrancesco Ruggeri port->count += 1;
94530837960SFrancesco Ruggeri
946291ac684SZiyang Xuan /* Get macvlan's reference to lowerdev */
947d62607c3SJakub Kicinski netdev_hold(lowerdev, &vlan->dev_tracker, GFP_KERNEL);
948291ac684SZiyang Xuan
949b863ceb7SPatrick McHardy return 0;
950b863ceb7SPatrick McHardy }
951b863ceb7SPatrick McHardy
macvlan_uninit(struct net_device * dev)952fccaf710SEric Dumazet static void macvlan_uninit(struct net_device *dev)
953fccaf710SEric Dumazet {
954fccaf710SEric Dumazet struct macvlan_dev *vlan = netdev_priv(dev);
955d5cd9244SEric W. Biederman struct macvlan_port *port = vlan->port;
956fccaf710SEric Dumazet
9578ffab51bSEric Dumazet free_percpu(vlan->pcpu_stats);
958d5cd9244SEric W. Biederman
95979cf79abSMichael Braun macvlan_flush_sources(port, vlan);
9605e3c516bSDavid S. Miller port->count -= 1;
9615e3c516bSDavid S. Miller if (!port->count)
962d5cd9244SEric W. Biederman macvlan_port_destroy(port->dev);
963fccaf710SEric Dumazet }
964fccaf710SEric Dumazet
macvlan_dev_get_stats64(struct net_device * dev,struct rtnl_link_stats64 * stats)965bc1f4470Sstephen hemminger static void macvlan_dev_get_stats64(struct net_device *dev,
96628172739SEric Dumazet struct rtnl_link_stats64 *stats)
967fccaf710SEric Dumazet {
968fccaf710SEric Dumazet struct macvlan_dev *vlan = netdev_priv(dev);
969fccaf710SEric Dumazet
9708ffab51bSEric Dumazet if (vlan->pcpu_stats) {
971cdf3e274SLi RongQing struct vlan_pcpu_stats *p;
9728ffab51bSEric Dumazet u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes;
9738ffab51bSEric Dumazet u32 rx_errors = 0, tx_dropped = 0;
974bc66154eSEric Dumazet unsigned int start;
975fccaf710SEric Dumazet int i;
976fccaf710SEric Dumazet
977fccaf710SEric Dumazet for_each_possible_cpu(i) {
9788ffab51bSEric Dumazet p = per_cpu_ptr(vlan->pcpu_stats, i);
979bc66154eSEric Dumazet do {
980068c38adSThomas Gleixner start = u64_stats_fetch_begin(&p->syncp);
98109cca53cSEric Dumazet rx_packets = u64_stats_read(&p->rx_packets);
98209cca53cSEric Dumazet rx_bytes = u64_stats_read(&p->rx_bytes);
98309cca53cSEric Dumazet rx_multicast = u64_stats_read(&p->rx_multicast);
98409cca53cSEric Dumazet tx_packets = u64_stats_read(&p->tx_packets);
98509cca53cSEric Dumazet tx_bytes = u64_stats_read(&p->tx_bytes);
986068c38adSThomas Gleixner } while (u64_stats_fetch_retry(&p->syncp, start));
9878ffab51bSEric Dumazet
9888ffab51bSEric Dumazet stats->rx_packets += rx_packets;
9898ffab51bSEric Dumazet stats->rx_bytes += rx_bytes;
9908ffab51bSEric Dumazet stats->multicast += rx_multicast;
9918ffab51bSEric Dumazet stats->tx_packets += tx_packets;
9928ffab51bSEric Dumazet stats->tx_bytes += tx_bytes;
9938ffab51bSEric Dumazet /* rx_errors & tx_dropped are u32, updated
9948ffab51bSEric Dumazet * without syncp protection.
9958ffab51bSEric Dumazet */
99609cca53cSEric Dumazet rx_errors += READ_ONCE(p->rx_errors);
99709cca53cSEric Dumazet tx_dropped += READ_ONCE(p->tx_dropped);
998fccaf710SEric Dumazet }
9998ffab51bSEric Dumazet stats->rx_errors = rx_errors;
10008ffab51bSEric Dumazet stats->rx_dropped = rx_errors;
10018ffab51bSEric Dumazet stats->tx_dropped = tx_dropped;
1002fccaf710SEric Dumazet }
1003fccaf710SEric Dumazet }
1004fccaf710SEric Dumazet
macvlan_vlan_rx_add_vid(struct net_device * dev,__be16 proto,u16 vid)10058e586137SJiri Pirko static int macvlan_vlan_rx_add_vid(struct net_device *dev,
100680d5c368SPatrick McHardy __be16 proto, u16 vid)
10078d13e670SJohn Fastabend {
10088d13e670SJohn Fastabend struct macvlan_dev *vlan = netdev_priv(dev);
10098d13e670SJohn Fastabend struct net_device *lowerdev = vlan->lowerdev;
10108d13e670SJohn Fastabend
101180d5c368SPatrick McHardy return vlan_vid_add(lowerdev, proto, vid);
10128d13e670SJohn Fastabend }
10138d13e670SJohn Fastabend
macvlan_vlan_rx_kill_vid(struct net_device * dev,__be16 proto,u16 vid)10148e586137SJiri Pirko static int macvlan_vlan_rx_kill_vid(struct net_device *dev,
101580d5c368SPatrick McHardy __be16 proto, u16 vid)
10168d13e670SJohn Fastabend {
10178d13e670SJohn Fastabend struct macvlan_dev *vlan = netdev_priv(dev);
10188d13e670SJohn Fastabend struct net_device *lowerdev = vlan->lowerdev;
10198d13e670SJohn Fastabend
102080d5c368SPatrick McHardy vlan_vid_del(lowerdev, proto, vid);
10218e586137SJiri Pirko return 0;
10228d13e670SJohn Fastabend }
10238d13e670SJohn Fastabend
macvlan_fdb_add(struct ndmsg * ndm,struct nlattr * tb[],struct net_device * dev,const unsigned char * addr,u16 vid,u16 flags,struct netlink_ext_ack * extack)1024edc7d573Sstephen hemminger static int macvlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1025df8ef8f3SJohn Fastabend struct net_device *dev,
1026f6f6424bSJiri Pirko const unsigned char *addr, u16 vid,
102787b0984eSPetr Machata u16 flags,
102887b0984eSPetr Machata struct netlink_ext_ack *extack)
1029df8ef8f3SJohn Fastabend {
1030df8ef8f3SJohn Fastabend struct macvlan_dev *vlan = netdev_priv(dev);
1031df8ef8f3SJohn Fastabend int err = -EINVAL;
1032df8ef8f3SJohn Fastabend
10338a50f11cSVlad Yasevich /* Support unicast filter only on passthru devices.
10348a50f11cSVlad Yasevich * Multicast filter should be allowed on all devices.
10358a50f11cSVlad Yasevich */
103643c2d578SVlad Yasevich if (!macvlan_passthru(vlan->port) && is_unicast_ether_addr(addr))
1037df8ef8f3SJohn Fastabend return -EOPNOTSUPP;
1038df8ef8f3SJohn Fastabend
1039ab2cfbb2SThomas Richter if (flags & NLM_F_REPLACE)
1040ab2cfbb2SThomas Richter return -EOPNOTSUPP;
1041ab2cfbb2SThomas Richter
1042df8ef8f3SJohn Fastabend if (is_unicast_ether_addr(addr))
1043df8ef8f3SJohn Fastabend err = dev_uc_add_excl(dev, addr);
1044df8ef8f3SJohn Fastabend else if (is_multicast_ether_addr(addr))
1045df8ef8f3SJohn Fastabend err = dev_mc_add_excl(dev, addr);
1046df8ef8f3SJohn Fastabend
1047df8ef8f3SJohn Fastabend return err;
1048df8ef8f3SJohn Fastabend }
1049df8ef8f3SJohn Fastabend
macvlan_fdb_del(struct ndmsg * ndm,struct nlattr * tb[],struct net_device * dev,const unsigned char * addr,u16 vid,struct netlink_ext_ack * extack)10501690be63SVlad Yasevich static int macvlan_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
1051df8ef8f3SJohn Fastabend struct net_device *dev,
1052ca4567f1SAlaa Mohamed const unsigned char *addr, u16 vid,
1053ca4567f1SAlaa Mohamed struct netlink_ext_ack *extack)
1054df8ef8f3SJohn Fastabend {
1055df8ef8f3SJohn Fastabend struct macvlan_dev *vlan = netdev_priv(dev);
1056df8ef8f3SJohn Fastabend int err = -EINVAL;
1057df8ef8f3SJohn Fastabend
10588a50f11cSVlad Yasevich /* Support unicast filter only on passthru devices.
10598a50f11cSVlad Yasevich * Multicast filter should be allowed on all devices.
10608a50f11cSVlad Yasevich */
106143c2d578SVlad Yasevich if (!macvlan_passthru(vlan->port) && is_unicast_ether_addr(addr))
1062df8ef8f3SJohn Fastabend return -EOPNOTSUPP;
1063df8ef8f3SJohn Fastabend
1064df8ef8f3SJohn Fastabend if (is_unicast_ether_addr(addr))
1065df8ef8f3SJohn Fastabend err = dev_uc_del(dev, addr);
1066df8ef8f3SJohn Fastabend else if (is_multicast_ether_addr(addr))
1067df8ef8f3SJohn Fastabend err = dev_mc_del(dev, addr);
1068df8ef8f3SJohn Fastabend
1069df8ef8f3SJohn Fastabend return err;
1070df8ef8f3SJohn Fastabend }
1071df8ef8f3SJohn Fastabend
macvlan_ethtool_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * drvinfo)1072b863ceb7SPatrick McHardy static void macvlan_ethtool_get_drvinfo(struct net_device *dev,
1073b863ceb7SPatrick McHardy struct ethtool_drvinfo *drvinfo)
1074b863ceb7SPatrick McHardy {
1075fb3ceec1SWolfram Sang strscpy(drvinfo->driver, "macvlan", sizeof(drvinfo->driver));
1076fb3ceec1SWolfram Sang strscpy(drvinfo->version, "0.1", sizeof(drvinfo->version));
1077b863ceb7SPatrick McHardy }
1078b863ceb7SPatrick McHardy
macvlan_ethtool_get_link_ksettings(struct net_device * dev,struct ethtool_link_ksettings * cmd)107985f95819SDavid Decotigny static int macvlan_ethtool_get_link_ksettings(struct net_device *dev,
108085f95819SDavid Decotigny struct ethtool_link_ksettings *cmd)
10819edb8bb6SStephen Hemminger {
10829edb8bb6SStephen Hemminger const struct macvlan_dev *vlan = netdev_priv(dev);
10834bc71cb9SJiri Pirko
108485f95819SDavid Decotigny return __ethtool_get_link_ksettings(vlan->lowerdev, cmd);
10859edb8bb6SStephen Hemminger }
10869edb8bb6SStephen Hemminger
macvlan_ethtool_get_ts_info(struct net_device * dev,struct kernel_ethtool_ts_info * info)1087254c0a2bSHangbin Liu static int macvlan_ethtool_get_ts_info(struct net_device *dev,
10882111375bSKory Maincent struct kernel_ethtool_ts_info *info)
1089254c0a2bSHangbin Liu {
1090254c0a2bSHangbin Liu struct net_device *real_dev = macvlan_dev_real_dev(dev);
1091254c0a2bSHangbin Liu
1092b8768dc4SRichard Cochran return ethtool_get_ts_info_by_layer(real_dev, info);
1093254c0a2bSHangbin Liu }
1094254c0a2bSHangbin Liu
macvlan_fix_features(struct net_device * dev,netdev_features_t features)10952be5c767SVlad Yasevich static netdev_features_t macvlan_fix_features(struct net_device *dev,
10962be5c767SVlad Yasevich netdev_features_t features)
10972be5c767SVlad Yasevich {
10982be5c767SVlad Yasevich struct macvlan_dev *vlan = netdev_priv(dev);
109962dbe830SMichal Kubeček netdev_features_t lowerdev_features = vlan->lowerdev->features;
1100797f87f8SFlorian Westphal netdev_features_t mask;
11012be5c767SVlad Yasevich
1102797f87f8SFlorian Westphal features |= NETIF_F_ALL_FOR_ALL;
1103797f87f8SFlorian Westphal features &= (vlan->set_features | ~MACVLAN_FEATURES);
1104797f87f8SFlorian Westphal mask = features;
1105797f87f8SFlorian Westphal
110662dbe830SMichal Kubeček lowerdev_features &= (features | ~NETIF_F_LRO);
110762dbe830SMichal Kubeček features = netdev_increment_features(lowerdev_features, features, mask);
11088b4703e9SVlad Yasevich features |= ALWAYS_ON_FEATURES;
110913fbcc8dSShannon Nelson features &= (ALWAYS_ON_FEATURES | MACVLAN_FEATURES);
1110797f87f8SFlorian Westphal
1111797f87f8SFlorian Westphal return features;
11122be5c767SVlad Yasevich }
11132be5c767SVlad Yasevich
1114688cea83Sdingtianhong #ifdef CONFIG_NET_POLL_CONTROLLER
macvlan_dev_poll_controller(struct net_device * dev)1115688cea83Sdingtianhong static void macvlan_dev_poll_controller(struct net_device *dev)
1116688cea83Sdingtianhong {
1117688cea83Sdingtianhong return;
1118688cea83Sdingtianhong }
1119688cea83Sdingtianhong
macvlan_dev_netpoll_setup(struct net_device * dev,struct netpoll_info * npinfo)1120688cea83Sdingtianhong static int macvlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo)
1121688cea83Sdingtianhong {
1122688cea83Sdingtianhong struct macvlan_dev *vlan = netdev_priv(dev);
1123688cea83Sdingtianhong struct net_device *real_dev = vlan->lowerdev;
1124688cea83Sdingtianhong struct netpoll *netpoll;
1125419a38ceSMenglong Dong int err;
1126688cea83Sdingtianhong
1127688cea83Sdingtianhong netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL);
1128688cea83Sdingtianhong err = -ENOMEM;
1129688cea83Sdingtianhong if (!netpoll)
1130688cea83Sdingtianhong goto out;
1131688cea83Sdingtianhong
1132688cea83Sdingtianhong err = __netpoll_setup(netpoll, real_dev);
1133688cea83Sdingtianhong if (err) {
1134688cea83Sdingtianhong kfree(netpoll);
1135688cea83Sdingtianhong goto out;
1136688cea83Sdingtianhong }
1137688cea83Sdingtianhong
1138688cea83Sdingtianhong vlan->netpoll = netpoll;
1139688cea83Sdingtianhong
1140688cea83Sdingtianhong out:
1141688cea83Sdingtianhong return err;
1142688cea83Sdingtianhong }
1143688cea83Sdingtianhong
macvlan_dev_netpoll_cleanup(struct net_device * dev)1144688cea83Sdingtianhong static void macvlan_dev_netpoll_cleanup(struct net_device *dev)
1145688cea83Sdingtianhong {
1146688cea83Sdingtianhong struct macvlan_dev *vlan = netdev_priv(dev);
1147688cea83Sdingtianhong struct netpoll *netpoll = vlan->netpoll;
1148688cea83Sdingtianhong
1149688cea83Sdingtianhong if (!netpoll)
1150688cea83Sdingtianhong return;
1151688cea83Sdingtianhong
1152688cea83Sdingtianhong vlan->netpoll = NULL;
1153688cea83Sdingtianhong
1154c9fbd71fSDebabrata Banerjee __netpoll_free(netpoll);
1155688cea83Sdingtianhong }
1156688cea83Sdingtianhong #endif /* CONFIG_NET_POLL_CONTROLLER */
1157688cea83Sdingtianhong
macvlan_dev_get_iflink(const struct net_device * dev)1158ef5fa6bcSNicolas Dichtel static int macvlan_dev_get_iflink(const struct net_device *dev)
1159ef5fa6bcSNicolas Dichtel {
1160ef5fa6bcSNicolas Dichtel struct macvlan_dev *vlan = netdev_priv(dev);
1161ef5fa6bcSNicolas Dichtel
1162e353ea9cSEric Dumazet return READ_ONCE(vlan->lowerdev->ifindex);
1163ef5fa6bcSNicolas Dichtel }
1164ef5fa6bcSNicolas Dichtel
1165b863ceb7SPatrick McHardy static const struct ethtool_ops macvlan_ethtool_ops = {
1166b863ceb7SPatrick McHardy .get_link = ethtool_op_get_link,
116785f95819SDavid Decotigny .get_link_ksettings = macvlan_ethtool_get_link_ksettings,
1168b863ceb7SPatrick McHardy .get_drvinfo = macvlan_ethtool_get_drvinfo,
1169254c0a2bSHangbin Liu .get_ts_info = macvlan_ethtool_get_ts_info,
1170b863ceb7SPatrick McHardy };
1171b863ceb7SPatrick McHardy
117254a30c97SStephen Hemminger static const struct net_device_ops macvlan_netdev_ops = {
117354a30c97SStephen Hemminger .ndo_init = macvlan_init,
1174fccaf710SEric Dumazet .ndo_uninit = macvlan_uninit,
117554a30c97SStephen Hemminger .ndo_open = macvlan_open,
117654a30c97SStephen Hemminger .ndo_stop = macvlan_stop,
117700829823SStephen Hemminger .ndo_start_xmit = macvlan_start_xmit,
117854a30c97SStephen Hemminger .ndo_change_mtu = macvlan_change_mtu,
11792be5c767SVlad Yasevich .ndo_fix_features = macvlan_fix_features,
118054a30c97SStephen Hemminger .ndo_change_rx_flags = macvlan_change_rx_flags,
118154a30c97SStephen Hemminger .ndo_set_mac_address = macvlan_set_mac_address,
1182df8ef8f3SJohn Fastabend .ndo_set_rx_mode = macvlan_set_mac_lists,
1183bc66154eSEric Dumazet .ndo_get_stats64 = macvlan_dev_get_stats64,
118454a30c97SStephen Hemminger .ndo_validate_addr = eth_validate_addr,
11858d13e670SJohn Fastabend .ndo_vlan_rx_add_vid = macvlan_vlan_rx_add_vid,
11868d13e670SJohn Fastabend .ndo_vlan_rx_kill_vid = macvlan_vlan_rx_kill_vid,
1187df8ef8f3SJohn Fastabend .ndo_fdb_add = macvlan_fdb_add,
1188df8ef8f3SJohn Fastabend .ndo_fdb_del = macvlan_fdb_del,
1189df8ef8f3SJohn Fastabend .ndo_fdb_dump = ndo_dflt_fdb_dump,
1190688cea83Sdingtianhong #ifdef CONFIG_NET_POLL_CONTROLLER
1191688cea83Sdingtianhong .ndo_poll_controller = macvlan_dev_poll_controller,
1192688cea83Sdingtianhong .ndo_netpoll_setup = macvlan_dev_netpoll_setup,
1193688cea83Sdingtianhong .ndo_netpoll_cleanup = macvlan_dev_netpoll_cleanup,
1194688cea83Sdingtianhong #endif
1195ef5fa6bcSNicolas Dichtel .ndo_get_iflink = macvlan_dev_get_iflink,
1196f56e67b5SToshiaki Makita .ndo_features_check = passthru_features_check,
11970bca3f7fSMaxim Georgiev .ndo_hwtstamp_get = macvlan_hwtstamp_get,
11980bca3f7fSMaxim Georgiev .ndo_hwtstamp_set = macvlan_hwtstamp_set,
119954a30c97SStephen Hemminger };
120054a30c97SStephen Hemminger
macvlan_dev_free(struct net_device * dev)1201291ac684SZiyang Xuan static void macvlan_dev_free(struct net_device *dev)
1202291ac684SZiyang Xuan {
1203291ac684SZiyang Xuan struct macvlan_dev *vlan = netdev_priv(dev);
1204291ac684SZiyang Xuan
1205291ac684SZiyang Xuan /* Get rid of the macvlan's reference to lowerdev */
1206d62607c3SJakub Kicinski netdev_put(vlan->lowerdev, &vlan->dev_tracker);
1207291ac684SZiyang Xuan }
1208291ac684SZiyang Xuan
macvlan_common_setup(struct net_device * dev)12098a35747aSHerbert Xu void macvlan_common_setup(struct net_device *dev)
1210b863ceb7SPatrick McHardy {
1211b863ceb7SPatrick McHardy ether_setup(dev);
1212b863ceb7SPatrick McHardy
1213b64085b0SEric Dumazet /* ether_setup() has set dev->min_mtu to ETH_MIN_MTU. */
121491572088SJarod Wilson dev->max_mtu = ETH_MAX_MTU;
121502875878SEric Dumazet dev->priv_flags &= ~IFF_TX_SKB_SHARING;
121602875878SEric Dumazet netif_keep_dst(dev);
1217beb5a9beSAlexander Lobakin dev->priv_flags |= IFF_UNICAST_FLT;
1218beb5a9beSAlexander Lobakin dev->change_proto_down = true;
121954a30c97SStephen Hemminger dev->netdev_ops = &macvlan_netdev_ops;
1220cf124db5SDavid S. Miller dev->needs_free_netdev = true;
1221291ac684SZiyang Xuan dev->priv_destructor = macvlan_dev_free;
122271740129SLutz Jaenicke dev->header_ops = &macvlan_hard_header_ops;
1223b863ceb7SPatrick McHardy dev->ethtool_ops = &macvlan_ethtool_ops;
12248a35747aSHerbert Xu }
12258a35747aSHerbert Xu EXPORT_SYMBOL_GPL(macvlan_common_setup);
12268a35747aSHerbert Xu
macvlan_setup(struct net_device * dev)12278a35747aSHerbert Xu static void macvlan_setup(struct net_device *dev)
12288a35747aSHerbert Xu {
12298a35747aSHerbert Xu macvlan_common_setup(dev);
12307009212bSZhang Shengju dev->priv_flags |= IFF_NO_QUEUE;
1231b863ceb7SPatrick McHardy }
1232b863ceb7SPatrick McHardy
macvlan_port_create(struct net_device * dev)1233b863ceb7SPatrick McHardy static int macvlan_port_create(struct net_device *dev)
1234b863ceb7SPatrick McHardy {
1235b863ceb7SPatrick McHardy struct macvlan_port *port;
1236b863ceb7SPatrick McHardy unsigned int i;
1237ab95bfe0SJiri Pirko int err;
1238b863ceb7SPatrick McHardy
1239b863ceb7SPatrick McHardy if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK)
1240b863ceb7SPatrick McHardy return -EINVAL;
1241b863ceb7SPatrick McHardy
1242322dc6e0SMahesh Bandewar if (netdev_is_rx_handler_busy(dev))
1243d6b00fecSMahesh Bandewar return -EBUSY;
1244d6b00fecSMahesh Bandewar
1245b863ceb7SPatrick McHardy port = kzalloc(sizeof(*port), GFP_KERNEL);
1246b863ceb7SPatrick McHardy if (port == NULL)
1247b863ceb7SPatrick McHardy return -ENOMEM;
1248b863ceb7SPatrick McHardy
1249b863ceb7SPatrick McHardy port->dev = dev;
125018c8c54dSVlad Yasevich ether_addr_copy(port->perm_addr, dev->dev_addr);
1251b863ceb7SPatrick McHardy INIT_LIST_HEAD(&port->vlans);
1252b863ceb7SPatrick McHardy for (i = 0; i < MACVLAN_HASH_SIZE; i++)
1253b863ceb7SPatrick McHardy INIT_HLIST_HEAD(&port->vlan_hash[i]);
125479cf79abSMichael Braun for (i = 0; i < MACVLAN_HASH_SIZE; i++)
125579cf79abSMichael Braun INIT_HLIST_HEAD(&port->vlan_source_hash[i]);
1256ab95bfe0SJiri Pirko
1257d4bff72cSThomas Karlsson port->bc_queue_len_used = 0;
1258954d1fa1SHerbert Xu port->bc_cutoff = 1;
1259412ca155SHerbert Xu skb_queue_head_init(&port->bc_queue);
1260412ca155SHerbert Xu INIT_WORK(&port->bc_work, macvlan_process_broadcast);
1261412ca155SHerbert Xu
1262a35e2c1bSJiri Pirko err = netdev_rx_handler_register(dev, macvlan_handle_frame, port);
1263a35e2c1bSJiri Pirko if (err)
1264ab95bfe0SJiri Pirko kfree(port);
1265d9351561SEric Dumazet else
1266a35e2c1bSJiri Pirko dev->priv_flags |= IFF_MACVLAN_PORT;
1267ab95bfe0SJiri Pirko return err;
1268b863ceb7SPatrick McHardy }
1269b863ceb7SPatrick McHardy
macvlan_port_destroy(struct net_device * dev)1270b863ceb7SPatrick McHardy static void macvlan_port_destroy(struct net_device *dev)
1271b863ceb7SPatrick McHardy {
1272e052f7e6SEric Dumazet struct macvlan_port *port = macvlan_port_get_rtnl(dev);
1273f6478218SHerbert Xu struct sk_buff *skb;
1274b863ceb7SPatrick McHardy
1275a35e2c1bSJiri Pirko dev->priv_flags &= ~IFF_MACVLAN_PORT;
1276ab95bfe0SJiri Pirko netdev_rx_handler_unregister(dev);
1277fe0ca732SEric Dumazet
1278fe0ca732SEric Dumazet /* After this point, no packet can schedule bc_work anymore,
1279fe0ca732SEric Dumazet * but we need to cancel it and purge left skbs if any.
1280fe0ca732SEric Dumazet */
1281fe0ca732SEric Dumazet cancel_work_sync(&port->bc_work);
1282f6478218SHerbert Xu
1283f6478218SHerbert Xu while ((skb = __skb_dequeue(&port->bc_queue))) {
1284f6478218SHerbert Xu const struct macvlan_dev *src = MACVLAN_SKB_CB(skb)->src;
1285f6478218SHerbert Xu
1286f6478218SHerbert Xu if (src)
1287f6478218SHerbert Xu dev_put(src->dev);
1288f6478218SHerbert Xu
1289f6478218SHerbert Xu kfree_skb(skb);
1290f6478218SHerbert Xu }
1291fe0ca732SEric Dumazet
129218c8c54dSVlad Yasevich /* If the lower device address has been changed by passthru
129318c8c54dSVlad Yasevich * macvlan, put it back.
129418c8c54dSVlad Yasevich */
129518c8c54dSVlad Yasevich if (macvlan_passthru(port) &&
129618c8c54dSVlad Yasevich !ether_addr_equal(port->dev->dev_addr, port->perm_addr)) {
129718c8c54dSVlad Yasevich struct sockaddr sa;
129818c8c54dSVlad Yasevich
129918c8c54dSVlad Yasevich sa.sa_family = port->dev->type;
130018c8c54dSVlad Yasevich memcpy(&sa.sa_data, port->perm_addr, port->dev->addr_len);
13013a37a963SPetr Machata dev_set_mac_address(port->dev, &sa, NULL);
130218c8c54dSVlad Yasevich }
130318c8c54dSVlad Yasevich
1304a1f5315cSGao Feng kfree(port);
1305b863ceb7SPatrick McHardy }
1306b863ceb7SPatrick McHardy
macvlan_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1307a8b8a889SMatthias Schiffer static int macvlan_validate(struct nlattr *tb[], struct nlattr *data[],
1308a8b8a889SMatthias Schiffer struct netlink_ext_ack *extack)
1309b863ceb7SPatrick McHardy {
13108b61fba5SAlvin Šipraga struct nlattr *nla, *head;
13118b61fba5SAlvin Šipraga int rem, len;
13128b61fba5SAlvin Šipraga
1313b863ceb7SPatrick McHardy if (tb[IFLA_ADDRESS]) {
1314b863ceb7SPatrick McHardy if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1315b863ceb7SPatrick McHardy return -EINVAL;
1316b863ceb7SPatrick McHardy if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1317b863ceb7SPatrick McHardy return -EADDRNOTAVAIL;
1318b863ceb7SPatrick McHardy }
131927c0b1a8SArnd Bergmann
132007850a4fSZhang Shengju if (!data)
132107850a4fSZhang Shengju return 0;
132207850a4fSZhang Shengju
132307850a4fSZhang Shengju if (data[IFLA_MACVLAN_FLAGS] &&
1324427f0c8cSJethro Beekman nla_get_u16(data[IFLA_MACVLAN_FLAGS]) & ~(MACVLAN_FLAG_NOPROMISC |
1325427f0c8cSJethro Beekman MACVLAN_FLAG_NODST))
132615127478SMichael S. Tsirkin return -EINVAL;
132715127478SMichael S. Tsirkin
132807850a4fSZhang Shengju if (data[IFLA_MACVLAN_MODE]) {
132927c0b1a8SArnd Bergmann switch (nla_get_u32(data[IFLA_MACVLAN_MODE])) {
133027c0b1a8SArnd Bergmann case MACVLAN_MODE_PRIVATE:
133127c0b1a8SArnd Bergmann case MACVLAN_MODE_VEPA:
133227c0b1a8SArnd Bergmann case MACVLAN_MODE_BRIDGE:
1333eb06acdcSSridhar Samudrala case MACVLAN_MODE_PASSTHRU:
133479cf79abSMichael Braun case MACVLAN_MODE_SOURCE:
133527c0b1a8SArnd Bergmann break;
133627c0b1a8SArnd Bergmann default:
133727c0b1a8SArnd Bergmann return -EINVAL;
133827c0b1a8SArnd Bergmann }
133927c0b1a8SArnd Bergmann }
134079cf79abSMichael Braun
134107850a4fSZhang Shengju if (data[IFLA_MACVLAN_MACADDR_MODE]) {
134279cf79abSMichael Braun switch (nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE])) {
134379cf79abSMichael Braun case MACVLAN_MACADDR_ADD:
134479cf79abSMichael Braun case MACVLAN_MACADDR_DEL:
134579cf79abSMichael Braun case MACVLAN_MACADDR_FLUSH:
134679cf79abSMichael Braun case MACVLAN_MACADDR_SET:
134779cf79abSMichael Braun break;
134879cf79abSMichael Braun default:
134979cf79abSMichael Braun return -EINVAL;
135079cf79abSMichael Braun }
135179cf79abSMichael Braun }
135279cf79abSMichael Braun
135307850a4fSZhang Shengju if (data[IFLA_MACVLAN_MACADDR]) {
135479cf79abSMichael Braun if (nla_len(data[IFLA_MACVLAN_MACADDR]) != ETH_ALEN)
135579cf79abSMichael Braun return -EINVAL;
135679cf79abSMichael Braun
135779cf79abSMichael Braun if (!is_valid_ether_addr(nla_data(data[IFLA_MACVLAN_MACADDR])))
135879cf79abSMichael Braun return -EADDRNOTAVAIL;
135979cf79abSMichael Braun }
136079cf79abSMichael Braun
13618b61fba5SAlvin Šipraga if (data[IFLA_MACVLAN_MACADDR_DATA]) {
13628b61fba5SAlvin Šipraga head = nla_data(data[IFLA_MACVLAN_MACADDR_DATA]);
13638b61fba5SAlvin Šipraga len = nla_len(data[IFLA_MACVLAN_MACADDR_DATA]);
13648b61fba5SAlvin Šipraga
13658b61fba5SAlvin Šipraga nla_for_each_attr(nla, head, len, rem) {
13668b61fba5SAlvin Šipraga if (nla_type(nla) != IFLA_MACVLAN_MACADDR ||
13678b61fba5SAlvin Šipraga nla_len(nla) != ETH_ALEN)
13688b61fba5SAlvin Šipraga return -EINVAL;
13698b61fba5SAlvin Šipraga
13708b61fba5SAlvin Šipraga if (!is_valid_ether_addr(nla_data(nla)))
13718b61fba5SAlvin Šipraga return -EADDRNOTAVAIL;
13728b61fba5SAlvin Šipraga }
13738b61fba5SAlvin Šipraga }
13748b61fba5SAlvin Šipraga
137507850a4fSZhang Shengju if (data[IFLA_MACVLAN_MACADDR_COUNT])
137679cf79abSMichael Braun return -EINVAL;
137779cf79abSMichael Braun
137879cf79abSMichael Braun return 0;
137979cf79abSMichael Braun }
138079cf79abSMichael Braun
138150a77e5fSLee Jones /*
138279cf79abSMichael Braun * reconfigure list of remote source mac address
138379cf79abSMichael Braun * (only for macvlan devices in source mode)
138479cf79abSMichael Braun * Note regarding alignment: all netlink data is aligned to 4 Byte, which
138579cf79abSMichael Braun * suffices for both ether_addr_copy and ether_addr_equal_64bits usage.
138679cf79abSMichael Braun */
macvlan_changelink_sources(struct macvlan_dev * vlan,u32 mode,struct nlattr * data[])138779cf79abSMichael Braun static int macvlan_changelink_sources(struct macvlan_dev *vlan, u32 mode,
138879cf79abSMichael Braun struct nlattr *data[])
138979cf79abSMichael Braun {
139079cf79abSMichael Braun char *addr = NULL;
139179cf79abSMichael Braun int ret, rem, len;
139279cf79abSMichael Braun struct nlattr *nla, *head;
139379cf79abSMichael Braun struct macvlan_source_entry *entry;
139479cf79abSMichael Braun
139579cf79abSMichael Braun if (data[IFLA_MACVLAN_MACADDR])
139679cf79abSMichael Braun addr = nla_data(data[IFLA_MACVLAN_MACADDR]);
139779cf79abSMichael Braun
139879cf79abSMichael Braun if (mode == MACVLAN_MACADDR_ADD) {
139979cf79abSMichael Braun if (!addr)
140079cf79abSMichael Braun return -EINVAL;
140179cf79abSMichael Braun
140279cf79abSMichael Braun return macvlan_hash_add_source(vlan, addr);
140379cf79abSMichael Braun
140479cf79abSMichael Braun } else if (mode == MACVLAN_MACADDR_DEL) {
140579cf79abSMichael Braun if (!addr)
140679cf79abSMichael Braun return -EINVAL;
140779cf79abSMichael Braun
140879cf79abSMichael Braun entry = macvlan_hash_lookup_source(vlan, addr);
140979cf79abSMichael Braun if (entry) {
141079cf79abSMichael Braun macvlan_hash_del_source(entry);
141179cf79abSMichael Braun vlan->macaddr_count--;
141279cf79abSMichael Braun }
141379cf79abSMichael Braun } else if (mode == MACVLAN_MACADDR_FLUSH) {
141479cf79abSMichael Braun macvlan_flush_sources(vlan->port, vlan);
141579cf79abSMichael Braun } else if (mode == MACVLAN_MACADDR_SET) {
141679cf79abSMichael Braun macvlan_flush_sources(vlan->port, vlan);
141779cf79abSMichael Braun
141879cf79abSMichael Braun if (addr) {
141979cf79abSMichael Braun ret = macvlan_hash_add_source(vlan, addr);
142079cf79abSMichael Braun if (ret)
142179cf79abSMichael Braun return ret;
142279cf79abSMichael Braun }
142379cf79abSMichael Braun
142489430ef3SYunjian Wang if (!data[IFLA_MACVLAN_MACADDR_DATA])
142579cf79abSMichael Braun return 0;
142679cf79abSMichael Braun
142779cf79abSMichael Braun head = nla_data(data[IFLA_MACVLAN_MACADDR_DATA]);
142879cf79abSMichael Braun len = nla_len(data[IFLA_MACVLAN_MACADDR_DATA]);
142979cf79abSMichael Braun
143079cf79abSMichael Braun nla_for_each_attr(nla, head, len, rem) {
143179cf79abSMichael Braun addr = nla_data(nla);
143279cf79abSMichael Braun ret = macvlan_hash_add_source(vlan, addr);
143379cf79abSMichael Braun if (ret)
143479cf79abSMichael Braun return ret;
143579cf79abSMichael Braun }
143679cf79abSMichael Braun } else {
143779cf79abSMichael Braun return -EINVAL;
143879cf79abSMichael Braun }
143979cf79abSMichael Braun
1440b863ceb7SPatrick McHardy return 0;
1441b863ceb7SPatrick McHardy }
1442b863ceb7SPatrick McHardy
macvlan_common_newlink(struct net * src_net,struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1443fc0663d6SArnd Bergmann int macvlan_common_newlink(struct net *src_net, struct net_device *dev,
144442ab19eeSDavid Ahern struct nlattr *tb[], struct nlattr *data[],
144542ab19eeSDavid Ahern struct netlink_ext_ack *extack)
1446b863ceb7SPatrick McHardy {
1447b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev);
1448b863ceb7SPatrick McHardy struct macvlan_port *port;
1449b863ceb7SPatrick McHardy struct net_device *lowerdev;
1450b863ceb7SPatrick McHardy int err;
145179cf79abSMichael Braun int macmode;
1452aa5fd0fbSGao Feng bool create = false;
1453b863ceb7SPatrick McHardy
1454b863ceb7SPatrick McHardy if (!tb[IFLA_LINK])
1455b863ceb7SPatrick McHardy return -EINVAL;
1456b863ceb7SPatrick McHardy
145781adee47SEric W. Biederman lowerdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
1458b863ceb7SPatrick McHardy if (lowerdev == NULL)
1459b863ceb7SPatrick McHardy return -ENODEV;
1460b863ceb7SPatrick McHardy
1461d70f2cf5SKevin Wallace /* When creating macvlans or macvtaps on top of other macvlans - use
1462b0832a29SEric Biederman * the real device as the lowerdev.
1463a6ca5f1dSPatrick McHardy */
1464d70f2cf5SKevin Wallace if (netif_is_macvlan(lowerdev))
1465d70f2cf5SKevin Wallace lowerdev = macvlan_dev_real_dev(lowerdev);
1466a6ca5f1dSPatrick McHardy
1467b863ceb7SPatrick McHardy if (!tb[IFLA_MTU])
1468b863ceb7SPatrick McHardy dev->mtu = lowerdev->mtu;
1469b863ceb7SPatrick McHardy else if (dev->mtu > lowerdev->mtu)
1470b863ceb7SPatrick McHardy return -EINVAL;
1471b863ceb7SPatrick McHardy
147291572088SJarod Wilson /* MTU range: 68 - lowerdev->max_mtu */
147391572088SJarod Wilson dev->min_mtu = ETH_MIN_MTU;
147491572088SJarod Wilson dev->max_mtu = lowerdev->max_mtu;
147591572088SJarod Wilson
1476b863ceb7SPatrick McHardy if (!tb[IFLA_ADDRESS])
14777ce5d222SDanny Kukawka eth_hw_addr_random(dev);
1478b863ceb7SPatrick McHardy
1479913564fbSJulian Wiedmann if (!netif_is_macvlan_port(lowerdev)) {
1480b863ceb7SPatrick McHardy err = macvlan_port_create(lowerdev);
1481b863ceb7SPatrick McHardy if (err < 0)
1482b863ceb7SPatrick McHardy return err;
1483aa5fd0fbSGao Feng create = true;
1484b863ceb7SPatrick McHardy }
1485e052f7e6SEric Dumazet port = macvlan_port_get_rtnl(lowerdev);
1486b863ceb7SPatrick McHardy
1487eb06acdcSSridhar Samudrala /* Only 1 macvlan device can be created in passthru mode */
148843c2d578SVlad Yasevich if (macvlan_passthru(port)) {
1489aa5fd0fbSGao Feng /* The macvlan port must be not created this time,
1490aa5fd0fbSGao Feng * still goto destroy_macvlan_port for readability.
1491aa5fd0fbSGao Feng */
1492aa5fd0fbSGao Feng err = -EINVAL;
1493aa5fd0fbSGao Feng goto destroy_macvlan_port;
1494aa5fd0fbSGao Feng }
1495eb06acdcSSridhar Samudrala
1496b863ceb7SPatrick McHardy vlan->lowerdev = lowerdev;
1497b863ceb7SPatrick McHardy vlan->dev = dev;
1498b863ceb7SPatrick McHardy vlan->port = port;
14992be5c767SVlad Yasevich vlan->set_features = MACVLAN_FEATURES;
1500b863ceb7SPatrick McHardy
150127c0b1a8SArnd Bergmann vlan->mode = MACVLAN_MODE_VEPA;
150227c0b1a8SArnd Bergmann if (data && data[IFLA_MACVLAN_MODE])
150327c0b1a8SArnd Bergmann vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);
150427c0b1a8SArnd Bergmann
1505df8ef8f3SJohn Fastabend if (data && data[IFLA_MACVLAN_FLAGS])
1506df8ef8f3SJohn Fastabend vlan->flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);
1507df8ef8f3SJohn Fastabend
1508eb06acdcSSridhar Samudrala if (vlan->mode == MACVLAN_MODE_PASSTHRU) {
1509aa5fd0fbSGao Feng if (port->count) {
1510aa5fd0fbSGao Feng err = -EINVAL;
1511aa5fd0fbSGao Feng goto destroy_macvlan_port;
1512aa5fd0fbSGao Feng }
151343c2d578SVlad Yasevich macvlan_set_passthru(port);
15148b98604eSBjørn Mork eth_hw_addr_inherit(dev, lowerdev);
1515eb06acdcSSridhar Samudrala }
1516eb06acdcSSridhar Samudrala
151779cf79abSMichael Braun if (data && data[IFLA_MACVLAN_MACADDR_MODE]) {
1518aa5fd0fbSGao Feng if (vlan->mode != MACVLAN_MODE_SOURCE) {
1519aa5fd0fbSGao Feng err = -EINVAL;
1520aa5fd0fbSGao Feng goto destroy_macvlan_port;
1521aa5fd0fbSGao Feng }
152279cf79abSMichael Braun macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]);
152379cf79abSMichael Braun err = macvlan_changelink_sources(vlan, macmode, data);
152479cf79abSMichael Braun if (err)
1525aa5fd0fbSGao Feng goto destroy_macvlan_port;
152679cf79abSMichael Braun }
152779cf79abSMichael Braun
1528d4bff72cSThomas Karlsson vlan->bc_queue_len_req = MACVLAN_DEFAULT_BC_QUEUE_LEN;
1529d4bff72cSThomas Karlsson if (data && data[IFLA_MACVLAN_BC_QUEUE_LEN])
1530d4bff72cSThomas Karlsson vlan->bc_queue_len_req = nla_get_u32(data[IFLA_MACVLAN_BC_QUEUE_LEN]);
1531d4bff72cSThomas Karlsson
1532954d1fa1SHerbert Xu if (data && data[IFLA_MACVLAN_BC_CUTOFF])
1533954d1fa1SHerbert Xu update_port_bc_cutoff(
1534954d1fa1SHerbert Xu vlan, nla_get_s32(data[IFLA_MACVLAN_BC_CUTOFF]));
1535954d1fa1SHerbert Xu
153647d4ab91SJohn Fastabend err = register_netdevice(dev);
153747d4ab91SJohn Fastabend if (err < 0)
1538aa5fd0fbSGao Feng goto destroy_macvlan_port;
153947d4ab91SJohn Fastabend
1540a6cc0cfaSJohn Fastabend dev->priv_flags |= IFF_MACVLAN;
154142ab19eeSDavid Ahern err = netdev_upper_dev_link(lowerdev, dev, extack);
15427cd43db7SJiri Pirko if (err)
1543da37705cSCong Wang goto unregister_netdev;
1544b863ceb7SPatrick McHardy
1545233c7df0SJiri Pirko list_add_tail_rcu(&vlan->list, &port->vlans);
1546d4bff72cSThomas Karlsson update_port_bc_queue_len(vlan->port);
1547fc4a7489SPatrick Mullaney netif_stacked_transfer_operstate(lowerdev, dev);
1548de7d244dSNikolay Aleksandrov linkwatch_fire_event(dev);
1549f16d3d57SJiri Pirko
1550b863ceb7SPatrick McHardy return 0;
1551f16d3d57SJiri Pirko
1552da37705cSCong Wang unregister_netdev:
1553d02fd6e7SGao Feng /* macvlan_uninit would free the macvlan port */
1554da37705cSCong Wang unregister_netdevice(dev);
1555d02fd6e7SGao Feng return err;
1556aa5fd0fbSGao Feng destroy_macvlan_port:
1557d02fd6e7SGao Feng /* the macvlan port may be freed by macvlan_uninit when fail to register.
1558d02fd6e7SGao Feng * so we destroy the macvlan port only when it's valid.
1559d02fd6e7SGao Feng */
156023569b56SChuang Wang if (create && macvlan_port_get_rtnl(lowerdev)) {
156123569b56SChuang Wang macvlan_flush_sources(port, vlan);
1562aa5fd0fbSGao Feng macvlan_port_destroy(port->dev);
156323569b56SChuang Wang }
1564f16d3d57SJiri Pirko return err;
1565b863ceb7SPatrick McHardy }
1566fc0663d6SArnd Bergmann EXPORT_SYMBOL_GPL(macvlan_common_newlink);
1567b863ceb7SPatrick McHardy
macvlan_newlink(struct net * src_net,struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1568fc0663d6SArnd Bergmann static int macvlan_newlink(struct net *src_net, struct net_device *dev,
15697a3f4a18SMatthias Schiffer struct nlattr *tb[], struct nlattr *data[],
15707a3f4a18SMatthias Schiffer struct netlink_ext_ack *extack)
1571fc0663d6SArnd Bergmann {
157242ab19eeSDavid Ahern return macvlan_common_newlink(src_net, dev, tb, data, extack);
1573fc0663d6SArnd Bergmann }
1574fc0663d6SArnd Bergmann
macvlan_dellink(struct net_device * dev,struct list_head * head)1575fc0663d6SArnd Bergmann void macvlan_dellink(struct net_device *dev, struct list_head *head)
1576b863ceb7SPatrick McHardy {
1577b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev);
1578b863ceb7SPatrick McHardy
157979cf79abSMichael Braun if (vlan->mode == MACVLAN_MODE_SOURCE)
158079cf79abSMichael Braun macvlan_flush_sources(vlan->port, vlan);
1581233c7df0SJiri Pirko list_del_rcu(&vlan->list);
1582d4bff72cSThomas Karlsson update_port_bc_queue_len(vlan->port);
158323289a37SEric Dumazet unregister_netdevice_queue(dev, head);
15847cd43db7SJiri Pirko netdev_upper_dev_unlink(vlan->lowerdev, dev);
1585b863ceb7SPatrick McHardy }
1586fc0663d6SArnd Bergmann EXPORT_SYMBOL_GPL(macvlan_dellink);
1587b863ceb7SPatrick McHardy
macvlan_changelink(struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)158827c0b1a8SArnd Bergmann static int macvlan_changelink(struct net_device *dev,
1589ad744b22SMatthias Schiffer struct nlattr *tb[], struct nlattr *data[],
1590ad744b22SMatthias Schiffer struct netlink_ext_ack *extack)
159127c0b1a8SArnd Bergmann {
159227c0b1a8SArnd Bergmann struct macvlan_dev *vlan = netdev_priv(dev);
1593266e8347SMichael S. Tsirkin enum macvlan_mode mode;
1594266e8347SMichael S. Tsirkin bool set_mode = false;
159579cf79abSMichael Braun enum macvlan_macaddr_mode macmode;
159679cf79abSMichael Braun int ret;
1597266e8347SMichael S. Tsirkin
1598266e8347SMichael S. Tsirkin /* Validate mode, but don't set yet: setting flags may fail. */
1599266e8347SMichael S. Tsirkin if (data && data[IFLA_MACVLAN_MODE]) {
1600266e8347SMichael S. Tsirkin set_mode = true;
1601266e8347SMichael S. Tsirkin mode = nla_get_u32(data[IFLA_MACVLAN_MODE]);
1602266e8347SMichael S. Tsirkin /* Passthrough mode can't be set or cleared dynamically */
1603266e8347SMichael S. Tsirkin if ((mode == MACVLAN_MODE_PASSTHRU) !=
1604266e8347SMichael S. Tsirkin (vlan->mode == MACVLAN_MODE_PASSTHRU))
1605266e8347SMichael S. Tsirkin return -EINVAL;
160679cf79abSMichael Braun if (vlan->mode == MACVLAN_MODE_SOURCE &&
160779cf79abSMichael Braun vlan->mode != mode)
160879cf79abSMichael Braun macvlan_flush_sources(vlan->port, vlan);
1609266e8347SMichael S. Tsirkin }
161099ffc3e7SMichael S. Tsirkin
1611df8ef8f3SJohn Fastabend if (data && data[IFLA_MACVLAN_FLAGS]) {
1612df8ef8f3SJohn Fastabend __u16 flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]);
1613df8ef8f3SJohn Fastabend bool promisc = (flags ^ vlan->flags) & MACVLAN_FLAG_NOPROMISC;
161443c2d578SVlad Yasevich if (macvlan_passthru(vlan->port) && promisc) {
161599ffc3e7SMichael S. Tsirkin int err;
1616df8ef8f3SJohn Fastabend
161799ffc3e7SMichael S. Tsirkin if (flags & MACVLAN_FLAG_NOPROMISC)
161899ffc3e7SMichael S. Tsirkin err = dev_set_promiscuity(vlan->lowerdev, -1);
161999ffc3e7SMichael S. Tsirkin else
162099ffc3e7SMichael S. Tsirkin err = dev_set_promiscuity(vlan->lowerdev, 1);
162199ffc3e7SMichael S. Tsirkin if (err < 0)
162299ffc3e7SMichael S. Tsirkin return err;
162399ffc3e7SMichael S. Tsirkin }
1624df8ef8f3SJohn Fastabend vlan->flags = flags;
1625df8ef8f3SJohn Fastabend }
1626d4bff72cSThomas Karlsson
1627d4bff72cSThomas Karlsson if (data && data[IFLA_MACVLAN_BC_QUEUE_LEN]) {
1628d4bff72cSThomas Karlsson vlan->bc_queue_len_req = nla_get_u32(data[IFLA_MACVLAN_BC_QUEUE_LEN]);
1629d4bff72cSThomas Karlsson update_port_bc_queue_len(vlan->port);
1630d4bff72cSThomas Karlsson }
1631d4bff72cSThomas Karlsson
1632954d1fa1SHerbert Xu if (data && data[IFLA_MACVLAN_BC_CUTOFF])
1633954d1fa1SHerbert Xu update_port_bc_cutoff(
1634954d1fa1SHerbert Xu vlan, nla_get_s32(data[IFLA_MACVLAN_BC_CUTOFF]));
1635954d1fa1SHerbert Xu
1636266e8347SMichael S. Tsirkin if (set_mode)
1637266e8347SMichael S. Tsirkin vlan->mode = mode;
163879cf79abSMichael Braun if (data && data[IFLA_MACVLAN_MACADDR_MODE]) {
163979cf79abSMichael Braun if (vlan->mode != MACVLAN_MODE_SOURCE)
164079cf79abSMichael Braun return -EINVAL;
164179cf79abSMichael Braun macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]);
164279cf79abSMichael Braun ret = macvlan_changelink_sources(vlan, macmode, data);
164379cf79abSMichael Braun if (ret)
164479cf79abSMichael Braun return ret;
164579cf79abSMichael Braun }
164627c0b1a8SArnd Bergmann return 0;
164727c0b1a8SArnd Bergmann }
164827c0b1a8SArnd Bergmann
macvlan_get_size_mac(const struct macvlan_dev * vlan)164979cf79abSMichael Braun static size_t macvlan_get_size_mac(const struct macvlan_dev *vlan)
165079cf79abSMichael Braun {
165179cf79abSMichael Braun if (vlan->macaddr_count == 0)
165279cf79abSMichael Braun return 0;
165379cf79abSMichael Braun return nla_total_size(0) /* IFLA_MACVLAN_MACADDR_DATA */
165479cf79abSMichael Braun + vlan->macaddr_count * nla_total_size(sizeof(u8) * ETH_ALEN);
165579cf79abSMichael Braun }
165679cf79abSMichael Braun
macvlan_get_size(const struct net_device * dev)165727c0b1a8SArnd Bergmann static size_t macvlan_get_size(const struct net_device *dev)
165827c0b1a8SArnd Bergmann {
165979cf79abSMichael Braun struct macvlan_dev *vlan = netdev_priv(dev);
166079cf79abSMichael Braun
166101fe944fSEric Dumazet return (0
166201fe944fSEric Dumazet + nla_total_size(4) /* IFLA_MACVLAN_MODE */
166301fe944fSEric Dumazet + nla_total_size(2) /* IFLA_MACVLAN_FLAGS */
166479cf79abSMichael Braun + nla_total_size(4) /* IFLA_MACVLAN_MACADDR_COUNT */
166579cf79abSMichael Braun + macvlan_get_size_mac(vlan) /* IFLA_MACVLAN_MACADDR */
1666d4bff72cSThomas Karlsson + nla_total_size(4) /* IFLA_MACVLAN_BC_QUEUE_LEN */
1667d4bff72cSThomas Karlsson + nla_total_size(4) /* IFLA_MACVLAN_BC_QUEUE_LEN_USED */
166801fe944fSEric Dumazet );
166927c0b1a8SArnd Bergmann }
167027c0b1a8SArnd Bergmann
macvlan_fill_info_macaddr(struct sk_buff * skb,const struct macvlan_dev * vlan,const int i)167179cf79abSMichael Braun static int macvlan_fill_info_macaddr(struct sk_buff *skb,
167279cf79abSMichael Braun const struct macvlan_dev *vlan,
167379cf79abSMichael Braun const int i)
167479cf79abSMichael Braun {
167579cf79abSMichael Braun struct hlist_head *h = &vlan->port->vlan_source_hash[i];
167679cf79abSMichael Braun struct macvlan_source_entry *entry;
167779cf79abSMichael Braun
16785df1341eSChuang Wang hlist_for_each_entry_rcu(entry, h, hlist, lockdep_rtnl_is_held()) {
167979cf79abSMichael Braun if (entry->vlan != vlan)
168079cf79abSMichael Braun continue;
168179cf79abSMichael Braun if (nla_put(skb, IFLA_MACVLAN_MACADDR, ETH_ALEN, entry->addr))
168279cf79abSMichael Braun return 1;
168379cf79abSMichael Braun }
168479cf79abSMichael Braun return 0;
168579cf79abSMichael Braun }
168679cf79abSMichael Braun
macvlan_fill_info(struct sk_buff * skb,const struct net_device * dev)168727c0b1a8SArnd Bergmann static int macvlan_fill_info(struct sk_buff *skb,
168827c0b1a8SArnd Bergmann const struct net_device *dev)
168927c0b1a8SArnd Bergmann {
169027c0b1a8SArnd Bergmann struct macvlan_dev *vlan = netdev_priv(dev);
1691d4bff72cSThomas Karlsson struct macvlan_port *port = vlan->port;
169279cf79abSMichael Braun int i;
169379cf79abSMichael Braun struct nlattr *nest;
169427c0b1a8SArnd Bergmann
1695ead9a76cSDavid S. Miller if (nla_put_u32(skb, IFLA_MACVLAN_MODE, vlan->mode))
1696ead9a76cSDavid S. Miller goto nla_put_failure;
1697df8ef8f3SJohn Fastabend if (nla_put_u16(skb, IFLA_MACVLAN_FLAGS, vlan->flags))
1698df8ef8f3SJohn Fastabend goto nla_put_failure;
169979cf79abSMichael Braun if (nla_put_u32(skb, IFLA_MACVLAN_MACADDR_COUNT, vlan->macaddr_count))
170079cf79abSMichael Braun goto nla_put_failure;
170179cf79abSMichael Braun if (vlan->macaddr_count > 0) {
1702ae0be8deSMichal Kubecek nest = nla_nest_start_noflag(skb, IFLA_MACVLAN_MACADDR_DATA);
170379cf79abSMichael Braun if (nest == NULL)
170479cf79abSMichael Braun goto nla_put_failure;
170579cf79abSMichael Braun
170679cf79abSMichael Braun for (i = 0; i < MACVLAN_HASH_SIZE; i++) {
170779cf79abSMichael Braun if (macvlan_fill_info_macaddr(skb, vlan, i))
170879cf79abSMichael Braun goto nla_put_failure;
170979cf79abSMichael Braun }
171079cf79abSMichael Braun nla_nest_end(skb, nest);
171179cf79abSMichael Braun }
1712d4bff72cSThomas Karlsson if (nla_put_u32(skb, IFLA_MACVLAN_BC_QUEUE_LEN, vlan->bc_queue_len_req))
1713d4bff72cSThomas Karlsson goto nla_put_failure;
1714d4bff72cSThomas Karlsson if (nla_put_u32(skb, IFLA_MACVLAN_BC_QUEUE_LEN_USED, port->bc_queue_len_used))
1715d4bff72cSThomas Karlsson goto nla_put_failure;
1716954d1fa1SHerbert Xu if (port->bc_cutoff != 1 &&
1717954d1fa1SHerbert Xu nla_put_s32(skb, IFLA_MACVLAN_BC_CUTOFF, port->bc_cutoff))
1718954d1fa1SHerbert Xu goto nla_put_failure;
171927c0b1a8SArnd Bergmann return 0;
172027c0b1a8SArnd Bergmann
172127c0b1a8SArnd Bergmann nla_put_failure:
172227c0b1a8SArnd Bergmann return -EMSGSIZE;
172327c0b1a8SArnd Bergmann }
172427c0b1a8SArnd Bergmann
172527c0b1a8SArnd Bergmann static const struct nla_policy macvlan_policy[IFLA_MACVLAN_MAX + 1] = {
172627c0b1a8SArnd Bergmann [IFLA_MACVLAN_MODE] = { .type = NLA_U32 },
1727df8ef8f3SJohn Fastabend [IFLA_MACVLAN_FLAGS] = { .type = NLA_U16 },
172879cf79abSMichael Braun [IFLA_MACVLAN_MACADDR_MODE] = { .type = NLA_U32 },
172979cf79abSMichael Braun [IFLA_MACVLAN_MACADDR] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
173079cf79abSMichael Braun [IFLA_MACVLAN_MACADDR_DATA] = { .type = NLA_NESTED },
173179cf79abSMichael Braun [IFLA_MACVLAN_MACADDR_COUNT] = { .type = NLA_U32 },
1732d4bff72cSThomas Karlsson [IFLA_MACVLAN_BC_QUEUE_LEN] = { .type = NLA_U32 },
1733d4bff72cSThomas Karlsson [IFLA_MACVLAN_BC_QUEUE_LEN_USED] = { .type = NLA_REJECT },
173455cef78cSLin Ma [IFLA_MACVLAN_BC_CUTOFF] = { .type = NLA_S32 },
173527c0b1a8SArnd Bergmann };
173627c0b1a8SArnd Bergmann
macvlan_link_register(struct rtnl_link_ops * ops)1737fc0663d6SArnd Bergmann int macvlan_link_register(struct rtnl_link_ops *ops)
1738fc0663d6SArnd Bergmann {
1739fc0663d6SArnd Bergmann /* common fields */
1740fc0663d6SArnd Bergmann ops->validate = macvlan_validate;
1741fc0663d6SArnd Bergmann ops->maxtype = IFLA_MACVLAN_MAX;
1742fc0663d6SArnd Bergmann ops->policy = macvlan_policy;
1743fc0663d6SArnd Bergmann ops->changelink = macvlan_changelink;
1744fc0663d6SArnd Bergmann ops->get_size = macvlan_get_size;
1745fc0663d6SArnd Bergmann ops->fill_info = macvlan_fill_info;
1746fc0663d6SArnd Bergmann
1747fc0663d6SArnd Bergmann return rtnl_link_register(ops);
1748fc0663d6SArnd Bergmann };
1749fc0663d6SArnd Bergmann EXPORT_SYMBOL_GPL(macvlan_link_register);
1750fc0663d6SArnd Bergmann
macvlan_get_link_net(const struct net_device * dev)1751eaca400fSNicolas Dichtel static struct net *macvlan_get_link_net(const struct net_device *dev)
1752eaca400fSNicolas Dichtel {
1753eaca400fSNicolas Dichtel return dev_net(macvlan_dev_real_dev(dev));
1754eaca400fSNicolas Dichtel }
1755eaca400fSNicolas Dichtel
1756fc0663d6SArnd Bergmann static struct rtnl_link_ops macvlan_link_ops = {
1757b863ceb7SPatrick McHardy .kind = "macvlan",
17588a35747aSHerbert Xu .setup = macvlan_setup,
1759b863ceb7SPatrick McHardy .newlink = macvlan_newlink,
1760b863ceb7SPatrick McHardy .dellink = macvlan_dellink,
1761eaca400fSNicolas Dichtel .get_link_net = macvlan_get_link_net,
17626fe3faf8SSainath Grandhi .priv_size = sizeof(struct macvlan_dev),
1763b863ceb7SPatrick McHardy };
1764b863ceb7SPatrick McHardy
update_port_bc_queue_len(struct macvlan_port * port)1765d4bff72cSThomas Karlsson static void update_port_bc_queue_len(struct macvlan_port *port)
1766d4bff72cSThomas Karlsson {
1767d4bff72cSThomas Karlsson u32 max_bc_queue_len_req = 0;
1768d4bff72cSThomas Karlsson struct macvlan_dev *vlan;
1769d4bff72cSThomas Karlsson
1770d4bff72cSThomas Karlsson list_for_each_entry(vlan, &port->vlans, list) {
1771d4bff72cSThomas Karlsson if (vlan->bc_queue_len_req > max_bc_queue_len_req)
1772d4bff72cSThomas Karlsson max_bc_queue_len_req = vlan->bc_queue_len_req;
1773d4bff72cSThomas Karlsson }
1774d4bff72cSThomas Karlsson port->bc_queue_len_used = max_bc_queue_len_req;
1775d4bff72cSThomas Karlsson }
1776d4bff72cSThomas Karlsson
macvlan_device_event(struct notifier_block * unused,unsigned long event,void * ptr)1777b863ceb7SPatrick McHardy static int macvlan_device_event(struct notifier_block *unused,
1778b863ceb7SPatrick McHardy unsigned long event, void *ptr)
1779b863ceb7SPatrick McHardy {
1780351638e7SJiri Pirko struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1781b863ceb7SPatrick McHardy struct macvlan_dev *vlan, *next;
1782b863ceb7SPatrick McHardy struct macvlan_port *port;
1783226bd341SEric Dumazet LIST_HEAD(list_kill);
1784b863ceb7SPatrick McHardy
1785913564fbSJulian Wiedmann if (!netif_is_macvlan_port(dev))
1786b863ceb7SPatrick McHardy return NOTIFY_DONE;
1787b863ceb7SPatrick McHardy
1788e052f7e6SEric Dumazet port = macvlan_port_get_rtnl(dev);
1789a35e2c1bSJiri Pirko
1790b863ceb7SPatrick McHardy switch (event) {
1791de7d244dSNikolay Aleksandrov case NETDEV_UP:
179280fd2d6cSTravis Brown case NETDEV_DOWN:
1793b863ceb7SPatrick McHardy case NETDEV_CHANGE:
1794b863ceb7SPatrick McHardy list_for_each_entry(vlan, &port->vlans, list)
1795fc4a7489SPatrick Mullaney netif_stacked_transfer_operstate(vlan->lowerdev,
1796fc4a7489SPatrick Mullaney vlan->dev);
1797b863ceb7SPatrick McHardy break;
1798b863ceb7SPatrick McHardy case NETDEV_FEAT_CHANGE:
1799b863ceb7SPatrick McHardy list_for_each_entry(vlan, &port->vlans, list) {
18006df6398fSJakub Kicinski netif_inherit_tso_max(vlan->dev, dev);
1801797f87f8SFlorian Westphal netdev_update_features(vlan->dev);
1802b863ceb7SPatrick McHardy }
1803b863ceb7SPatrick McHardy break;
18043763e7efSdingtianhong case NETDEV_CHANGEMTU:
18053763e7efSdingtianhong list_for_each_entry(vlan, &port->vlans, list) {
18063763e7efSdingtianhong if (vlan->dev->mtu <= dev->mtu)
18073763e7efSdingtianhong continue;
18083763e7efSdingtianhong dev_set_mtu(vlan->dev, dev->mtu);
18093763e7efSdingtianhong }
18103763e7efSdingtianhong break;
1811e289fd28Sdingtianhong case NETDEV_CHANGEADDR:
181243c2d578SVlad Yasevich if (!macvlan_passthru(port))
1813e289fd28Sdingtianhong return NOTIFY_DONE;
1814e289fd28Sdingtianhong
1815e289fd28Sdingtianhong vlan = list_first_entry_or_null(&port->vlans,
1816e289fd28Sdingtianhong struct macvlan_dev,
1817e289fd28Sdingtianhong list);
1818e289fd28Sdingtianhong
18194dee15b4STaehee Yoo if (vlan && macvlan_sync_address(vlan->dev, dev->dev_addr))
1820e289fd28Sdingtianhong return NOTIFY_BAD;
1821e289fd28Sdingtianhong
1822e289fd28Sdingtianhong break;
1823b863ceb7SPatrick McHardy case NETDEV_UNREGISTER:
18243b27e105SDavid Lamparter /* twiddle thumbs on netns device moves */
18253b27e105SDavid Lamparter if (dev->reg_state != NETREG_UNREGISTERING)
18263b27e105SDavid Lamparter break;
18273b27e105SDavid Lamparter
1828b863ceb7SPatrick McHardy list_for_each_entry_safe(vlan, next, &port->vlans, list)
1829226bd341SEric Dumazet vlan->dev->rtnl_link_ops->dellink(vlan->dev, &list_kill);
1830226bd341SEric Dumazet unregister_netdevice_many(&list_kill);
1831b863ceb7SPatrick McHardy break;
18321c01fe14SJiri Pirko case NETDEV_PRE_TYPE_CHANGE:
183326d3f69cSZheng Yongjun /* Forbid underlying device to change its type. */
18341c01fe14SJiri Pirko return NOTIFY_BAD;
18354c991255SVlad Yasevich
18364c991255SVlad Yasevich case NETDEV_NOTIFY_PEERS:
18374c991255SVlad Yasevich case NETDEV_BONDING_FAILOVER:
18384c991255SVlad Yasevich case NETDEV_RESEND_IGMP:
18394c991255SVlad Yasevich /* Propagate to all vlans */
18404c991255SVlad Yasevich list_for_each_entry(vlan, &port->vlans, list)
18414c991255SVlad Yasevich call_netdevice_notifiers(event, vlan->dev);
1842b863ceb7SPatrick McHardy }
1843b863ceb7SPatrick McHardy return NOTIFY_DONE;
1844b863ceb7SPatrick McHardy }
1845b863ceb7SPatrick McHardy
1846b863ceb7SPatrick McHardy static struct notifier_block macvlan_notifier_block __read_mostly = {
1847b863ceb7SPatrick McHardy .notifier_call = macvlan_device_event,
1848b863ceb7SPatrick McHardy };
1849b863ceb7SPatrick McHardy
macvlan_init_module(void)1850b863ceb7SPatrick McHardy static int __init macvlan_init_module(void)
1851b863ceb7SPatrick McHardy {
1852b863ceb7SPatrick McHardy int err;
1853b863ceb7SPatrick McHardy
1854b863ceb7SPatrick McHardy register_netdevice_notifier(&macvlan_notifier_block);
1855b863ceb7SPatrick McHardy
1856fc0663d6SArnd Bergmann err = macvlan_link_register(&macvlan_link_ops);
1857b863ceb7SPatrick McHardy if (err < 0)
1858b863ceb7SPatrick McHardy goto err1;
1859b863ceb7SPatrick McHardy return 0;
1860b863ceb7SPatrick McHardy err1:
1861b863ceb7SPatrick McHardy unregister_netdevice_notifier(&macvlan_notifier_block);
1862b863ceb7SPatrick McHardy return err;
1863b863ceb7SPatrick McHardy }
1864b863ceb7SPatrick McHardy
macvlan_cleanup_module(void)1865b863ceb7SPatrick McHardy static void __exit macvlan_cleanup_module(void)
1866b863ceb7SPatrick McHardy {
1867b863ceb7SPatrick McHardy rtnl_link_unregister(&macvlan_link_ops);
1868b863ceb7SPatrick McHardy unregister_netdevice_notifier(&macvlan_notifier_block);
1869b863ceb7SPatrick McHardy }
1870b863ceb7SPatrick McHardy
1871b863ceb7SPatrick McHardy module_init(macvlan_init_module);
1872b863ceb7SPatrick McHardy module_exit(macvlan_cleanup_module);
1873b863ceb7SPatrick McHardy
1874b863ceb7SPatrick McHardy MODULE_LICENSE("GPL");
1875b863ceb7SPatrick McHardy MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
1876b863ceb7SPatrick McHardy MODULE_DESCRIPTION("Driver for MAC address based VLANs");
1877b863ceb7SPatrick McHardy MODULE_ALIAS_RTNL_LINK("macvlan");
1878