1b863ceb7SPatrick McHardy /* 2b863ceb7SPatrick McHardy * Copyright (c) 2007 Patrick McHardy <kaber@trash.net> 3b863ceb7SPatrick McHardy * 4b863ceb7SPatrick McHardy * This program is free software; you can redistribute it and/or 5b863ceb7SPatrick McHardy * modify it under the terms of the GNU General Public License as 6b863ceb7SPatrick McHardy * published by the Free Software Foundation; either version 2 of 7b863ceb7SPatrick McHardy * the License, or (at your option) any later version. 8b863ceb7SPatrick McHardy * 9b863ceb7SPatrick McHardy * The code this is based on carried the following copyright notice: 10b863ceb7SPatrick McHardy * --- 11b863ceb7SPatrick McHardy * (C) Copyright 2001-2006 12b863ceb7SPatrick McHardy * Alex Zeffertt, Cambridge Broadband Ltd, ajz@cambridgebroadband.com 13b863ceb7SPatrick McHardy * Re-worked by Ben Greear <greearb@candelatech.com> 14b863ceb7SPatrick McHardy * --- 15b863ceb7SPatrick McHardy */ 16b863ceb7SPatrick McHardy #include <linux/kernel.h> 17b863ceb7SPatrick McHardy #include <linux/types.h> 18b863ceb7SPatrick McHardy #include <linux/module.h> 19b863ceb7SPatrick McHardy #include <linux/init.h> 20b863ceb7SPatrick McHardy #include <linux/errno.h> 21b863ceb7SPatrick McHardy #include <linux/slab.h> 22b863ceb7SPatrick McHardy #include <linux/string.h> 2382524746SFranck Bui-Huu #include <linux/rculist.h> 24b863ceb7SPatrick McHardy #include <linux/notifier.h> 25b863ceb7SPatrick McHardy #include <linux/netdevice.h> 26b863ceb7SPatrick McHardy #include <linux/etherdevice.h> 27b863ceb7SPatrick McHardy #include <linux/ethtool.h> 28b863ceb7SPatrick McHardy #include <linux/if_arp.h> 2987002b03SJiri Pirko #include <linux/if_vlan.h> 30b863ceb7SPatrick McHardy #include <linux/if_link.h> 31b863ceb7SPatrick McHardy #include <linux/if_macvlan.h> 32cd431e73SEric Dumazet #include <linux/hash.h> 33412ca155SHerbert Xu #include <linux/workqueue.h> 34b863ceb7SPatrick McHardy #include <net/rtnetlink.h> 35618e1b74SArnd Bergmann #include <net/xfrm.h> 36688cea83Sdingtianhong #include <linux/netpoll.h> 37b863ceb7SPatrick McHardy 3879cf79abSMichael Braun #define MACVLAN_HASH_BITS 8 3979cf79abSMichael Braun #define MACVLAN_HASH_SIZE (1<<MACVLAN_HASH_BITS) 4007d92d5cSNicolas Dichtel #define MACVLAN_BC_QUEUE_LEN 1000 41b863ceb7SPatrick McHardy 42b863ceb7SPatrick McHardy struct macvlan_port { 43b863ceb7SPatrick McHardy struct net_device *dev; 44b863ceb7SPatrick McHardy struct hlist_head vlan_hash[MACVLAN_HASH_SIZE]; 45b863ceb7SPatrick McHardy struct list_head vlans; 468b37ef0aSJiri Pirko struct rcu_head rcu; 47412ca155SHerbert Xu struct sk_buff_head bc_queue; 48412ca155SHerbert Xu struct work_struct bc_work; 49eb06acdcSSridhar Samudrala bool passthru; 505e3c516bSDavid S. Miller int count; 5179cf79abSMichael Braun struct hlist_head vlan_source_hash[MACVLAN_HASH_SIZE]; 5279cf79abSMichael Braun }; 5379cf79abSMichael Braun 5479cf79abSMichael Braun struct macvlan_source_entry { 5579cf79abSMichael Braun struct hlist_node hlist; 5679cf79abSMichael Braun struct macvlan_dev *vlan; 5779cf79abSMichael Braun unsigned char addr[6+2] __aligned(sizeof(u16)); 5879cf79abSMichael Braun struct rcu_head rcu; 59b863ceb7SPatrick McHardy }; 60b863ceb7SPatrick McHardy 61412ca155SHerbert Xu struct macvlan_skb_cb { 62412ca155SHerbert Xu const struct macvlan_dev *src; 63412ca155SHerbert Xu }; 64412ca155SHerbert Xu 65412ca155SHerbert Xu #define MACVLAN_SKB_CB(__skb) ((struct macvlan_skb_cb *)&((__skb)->cb[0])) 66412ca155SHerbert Xu 67d5cd9244SEric W. Biederman static void macvlan_port_destroy(struct net_device *dev); 68d5cd9244SEric W. Biederman 6979cf79abSMichael Braun /* Hash Ethernet address */ 7079cf79abSMichael Braun static u32 macvlan_eth_hash(const unsigned char *addr) 7179cf79abSMichael Braun { 7279cf79abSMichael Braun u64 value = get_unaligned((u64 *)addr); 7379cf79abSMichael Braun 7479cf79abSMichael Braun /* only want 6 bytes */ 7579cf79abSMichael Braun #ifdef __BIG_ENDIAN 7679cf79abSMichael Braun value >>= 16; 7779cf79abSMichael Braun #else 7879cf79abSMichael Braun value <<= 16; 7979cf79abSMichael Braun #endif 8079cf79abSMichael Braun return hash_64(value, MACVLAN_HASH_BITS); 8179cf79abSMichael Braun } 8279cf79abSMichael Braun 83e052f7e6SEric Dumazet static struct macvlan_port *macvlan_port_get_rcu(const struct net_device *dev) 84e052f7e6SEric Dumazet { 85e052f7e6SEric Dumazet return rcu_dereference(dev->rx_handler_data); 86e052f7e6SEric Dumazet } 87e052f7e6SEric Dumazet 88e052f7e6SEric Dumazet static struct macvlan_port *macvlan_port_get_rtnl(const struct net_device *dev) 89e052f7e6SEric Dumazet { 90e052f7e6SEric Dumazet return rtnl_dereference(dev->rx_handler_data); 91e052f7e6SEric Dumazet } 92e052f7e6SEric Dumazet 93a35e2c1bSJiri Pirko #define macvlan_port_exists(dev) (dev->priv_flags & IFF_MACVLAN_PORT) 94a35e2c1bSJiri Pirko 95b863ceb7SPatrick McHardy static struct macvlan_dev *macvlan_hash_lookup(const struct macvlan_port *port, 96b863ceb7SPatrick McHardy const unsigned char *addr) 97b863ceb7SPatrick McHardy { 98b863ceb7SPatrick McHardy struct macvlan_dev *vlan; 9979cf79abSMichael Braun u32 idx = macvlan_eth_hash(addr); 100b863ceb7SPatrick McHardy 10179cf79abSMichael Braun hlist_for_each_entry_rcu(vlan, &port->vlan_hash[idx], hlist) { 102a6700db1SJoe Perches if (ether_addr_equal_64bits(vlan->dev->dev_addr, addr)) 103b863ceb7SPatrick McHardy return vlan; 104b863ceb7SPatrick McHardy } 105b863ceb7SPatrick McHardy return NULL; 106b863ceb7SPatrick McHardy } 107b863ceb7SPatrick McHardy 10879cf79abSMichael Braun static struct macvlan_source_entry *macvlan_hash_lookup_source( 10979cf79abSMichael Braun const struct macvlan_dev *vlan, 11079cf79abSMichael Braun const unsigned char *addr) 11179cf79abSMichael Braun { 11279cf79abSMichael Braun struct macvlan_source_entry *entry; 11379cf79abSMichael Braun u32 idx = macvlan_eth_hash(addr); 11479cf79abSMichael Braun struct hlist_head *h = &vlan->port->vlan_source_hash[idx]; 11579cf79abSMichael Braun 11679cf79abSMichael Braun hlist_for_each_entry_rcu(entry, h, hlist) { 11779cf79abSMichael Braun if (ether_addr_equal_64bits(entry->addr, addr) && 11879cf79abSMichael Braun entry->vlan == vlan) 11979cf79abSMichael Braun return entry; 12079cf79abSMichael Braun } 12179cf79abSMichael Braun return NULL; 12279cf79abSMichael Braun } 12379cf79abSMichael Braun 12479cf79abSMichael Braun static int macvlan_hash_add_source(struct macvlan_dev *vlan, 12579cf79abSMichael Braun const unsigned char *addr) 12679cf79abSMichael Braun { 12779cf79abSMichael Braun struct macvlan_port *port = vlan->port; 12879cf79abSMichael Braun struct macvlan_source_entry *entry; 12979cf79abSMichael Braun struct hlist_head *h; 13079cf79abSMichael Braun 13179cf79abSMichael Braun entry = macvlan_hash_lookup_source(vlan, addr); 13279cf79abSMichael Braun if (entry) 13379cf79abSMichael Braun return 0; 13479cf79abSMichael Braun 13579cf79abSMichael Braun entry = kmalloc(sizeof(*entry), GFP_KERNEL); 13679cf79abSMichael Braun if (!entry) 13779cf79abSMichael Braun return -ENOMEM; 13879cf79abSMichael Braun 13979cf79abSMichael Braun ether_addr_copy(entry->addr, addr); 14079cf79abSMichael Braun entry->vlan = vlan; 14179cf79abSMichael Braun h = &port->vlan_source_hash[macvlan_eth_hash(addr)]; 14279cf79abSMichael Braun hlist_add_head_rcu(&entry->hlist, h); 14379cf79abSMichael Braun vlan->macaddr_count++; 14479cf79abSMichael Braun 14579cf79abSMichael Braun return 0; 14679cf79abSMichael Braun } 14779cf79abSMichael Braun 148f9ac30f0SEric Biederman static void macvlan_hash_add(struct macvlan_dev *vlan) 149f9ac30f0SEric Biederman { 150f9ac30f0SEric Biederman struct macvlan_port *port = vlan->port; 151f9ac30f0SEric Biederman const unsigned char *addr = vlan->dev->dev_addr; 15279cf79abSMichael Braun u32 idx = macvlan_eth_hash(addr); 153f9ac30f0SEric Biederman 15479cf79abSMichael Braun hlist_add_head_rcu(&vlan->hlist, &port->vlan_hash[idx]); 15579cf79abSMichael Braun } 15679cf79abSMichael Braun 15779cf79abSMichael Braun static void macvlan_hash_del_source(struct macvlan_source_entry *entry) 15879cf79abSMichael Braun { 15979cf79abSMichael Braun hlist_del_rcu(&entry->hlist); 16079cf79abSMichael Braun kfree_rcu(entry, rcu); 161f9ac30f0SEric Biederman } 162f9ac30f0SEric Biederman 163449f4544SEric Dumazet static void macvlan_hash_del(struct macvlan_dev *vlan, bool sync) 164f9ac30f0SEric Biederman { 165f9ac30f0SEric Biederman hlist_del_rcu(&vlan->hlist); 166449f4544SEric Dumazet if (sync) 167f9ac30f0SEric Biederman synchronize_rcu(); 168f9ac30f0SEric Biederman } 169f9ac30f0SEric Biederman 170f9ac30f0SEric Biederman static void macvlan_hash_change_addr(struct macvlan_dev *vlan, 171f9ac30f0SEric Biederman const unsigned char *addr) 172f9ac30f0SEric Biederman { 173449f4544SEric Dumazet macvlan_hash_del(vlan, true); 174f9ac30f0SEric Biederman /* Now that we are unhashed it is safe to change the device 175f9ac30f0SEric Biederman * address without confusing packet delivery. 176f9ac30f0SEric Biederman */ 177f9ac30f0SEric Biederman memcpy(vlan->dev->dev_addr, addr, ETH_ALEN); 178f9ac30f0SEric Biederman macvlan_hash_add(vlan); 179f9ac30f0SEric Biederman } 180f9ac30f0SEric Biederman 181f9ac30f0SEric Biederman static int macvlan_addr_busy(const struct macvlan_port *port, 182f9ac30f0SEric Biederman const unsigned char *addr) 183f9ac30f0SEric Biederman { 184f9ac30f0SEric Biederman /* Test to see if the specified multicast address is 185f9ac30f0SEric Biederman * currently in use by the underlying device or 186f9ac30f0SEric Biederman * another macvlan. 187f9ac30f0SEric Biederman */ 188a6700db1SJoe Perches if (ether_addr_equal_64bits(port->dev->dev_addr, addr)) 189f9ac30f0SEric Biederman return 1; 190f9ac30f0SEric Biederman 191f9ac30f0SEric Biederman if (macvlan_hash_lookup(port, addr)) 192f9ac30f0SEric Biederman return 1; 193f9ac30f0SEric Biederman 194f9ac30f0SEric Biederman return 0; 195f9ac30f0SEric Biederman } 196f9ac30f0SEric Biederman 197a1e514c5SArnd Bergmann 198fc0663d6SArnd Bergmann static int macvlan_broadcast_one(struct sk_buff *skb, 199fc0663d6SArnd Bergmann const struct macvlan_dev *vlan, 200618e1b74SArnd Bergmann const struct ethhdr *eth, bool local) 201a1e514c5SArnd Bergmann { 202fc0663d6SArnd Bergmann struct net_device *dev = vlan->dev; 203a1e514c5SArnd Bergmann 204618e1b74SArnd Bergmann if (local) 205412ca155SHerbert Xu return __dev_forward_skb(dev, skb); 206618e1b74SArnd Bergmann 207a1e514c5SArnd Bergmann skb->dev = dev; 208a6700db1SJoe Perches if (ether_addr_equal_64bits(eth->h_dest, dev->broadcast)) 209a1e514c5SArnd Bergmann skb->pkt_type = PACKET_BROADCAST; 210a1e514c5SArnd Bergmann else 211a1e514c5SArnd Bergmann skb->pkt_type = PACKET_MULTICAST; 212a1e514c5SArnd Bergmann 213412ca155SHerbert Xu return 0; 214a1e514c5SArnd Bergmann } 215a1e514c5SArnd Bergmann 2163807ff58SEric Dumazet static u32 macvlan_hash_mix(const struct macvlan_dev *vlan) 2173807ff58SEric Dumazet { 2183807ff58SEric Dumazet return (u32)(((unsigned long)vlan) >> L1_CACHE_SHIFT); 2193807ff58SEric Dumazet } 2203807ff58SEric Dumazet 2213807ff58SEric Dumazet 2223807ff58SEric Dumazet static unsigned int mc_hash(const struct macvlan_dev *vlan, 2233807ff58SEric Dumazet const unsigned char *addr) 224cd431e73SEric Dumazet { 225cd431e73SEric Dumazet u32 val = __get_unaligned_cpu32(addr + 2); 226cd431e73SEric Dumazet 2273807ff58SEric Dumazet val ^= macvlan_hash_mix(vlan); 228cd431e73SEric Dumazet return hash_32(val, MACVLAN_MC_FILTER_BITS); 229cd431e73SEric Dumazet } 230cd431e73SEric Dumazet 231b863ceb7SPatrick McHardy static void macvlan_broadcast(struct sk_buff *skb, 232618e1b74SArnd Bergmann const struct macvlan_port *port, 233618e1b74SArnd Bergmann struct net_device *src, 234618e1b74SArnd Bergmann enum macvlan_mode mode) 235b863ceb7SPatrick McHardy { 236b863ceb7SPatrick McHardy const struct ethhdr *eth = eth_hdr(skb); 237b863ceb7SPatrick McHardy const struct macvlan_dev *vlan; 238b863ceb7SPatrick McHardy struct sk_buff *nskb; 239b863ceb7SPatrick McHardy unsigned int i; 240a1e514c5SArnd Bergmann int err; 2413807ff58SEric Dumazet unsigned int hash; 242b863ceb7SPatrick McHardy 243efbbced3SPatrick McHardy if (skb->protocol == htons(ETH_P_PAUSE)) 244efbbced3SPatrick McHardy return; 245efbbced3SPatrick McHardy 246b863ceb7SPatrick McHardy for (i = 0; i < MACVLAN_HASH_SIZE; i++) { 247b67bfe0dSSasha Levin hlist_for_each_entry_rcu(vlan, &port->vlan_hash[i], hlist) { 248618e1b74SArnd Bergmann if (vlan->dev == src || !(vlan->mode & mode)) 249618e1b74SArnd Bergmann continue; 250618e1b74SArnd Bergmann 2513807ff58SEric Dumazet hash = mc_hash(vlan, eth->h_dest); 252cd431e73SEric Dumazet if (!test_bit(hash, vlan->mc_filter)) 253cd431e73SEric Dumazet continue; 254de9e8f3fSHerbert Xu 255de9e8f3fSHerbert Xu err = NET_RX_DROP; 256b863ceb7SPatrick McHardy nskb = skb_clone(skb, GFP_ATOMIC); 257de9e8f3fSHerbert Xu if (likely(nskb)) 258de9e8f3fSHerbert Xu err = macvlan_broadcast_one( 259de9e8f3fSHerbert Xu nskb, vlan, eth, 260412ca155SHerbert Xu mode == MACVLAN_MODE_BRIDGE) ?: 261412ca155SHerbert Xu netif_rx_ni(nskb); 262a1e514c5SArnd Bergmann macvlan_count_rx(vlan, skb->len + ETH_HLEN, 2634c979935Sjbaron@akamai.com err == NET_RX_SUCCESS, true); 264b863ceb7SPatrick McHardy } 265b863ceb7SPatrick McHardy } 266b863ceb7SPatrick McHardy } 267b863ceb7SPatrick McHardy 268412ca155SHerbert Xu static void macvlan_process_broadcast(struct work_struct *w) 269412ca155SHerbert Xu { 270412ca155SHerbert Xu struct macvlan_port *port = container_of(w, struct macvlan_port, 271412ca155SHerbert Xu bc_work); 272412ca155SHerbert Xu struct sk_buff *skb; 273412ca155SHerbert Xu struct sk_buff_head list; 274412ca155SHerbert Xu 275fe0ca732SEric Dumazet __skb_queue_head_init(&list); 276412ca155SHerbert Xu 277412ca155SHerbert Xu spin_lock_bh(&port->bc_queue.lock); 278412ca155SHerbert Xu skb_queue_splice_tail_init(&port->bc_queue, &list); 279412ca155SHerbert Xu spin_unlock_bh(&port->bc_queue.lock); 280412ca155SHerbert Xu 281412ca155SHerbert Xu while ((skb = __skb_dequeue(&list))) { 282412ca155SHerbert Xu const struct macvlan_dev *src = MACVLAN_SKB_CB(skb)->src; 283412ca155SHerbert Xu 284412ca155SHerbert Xu rcu_read_lock(); 285412ca155SHerbert Xu 286412ca155SHerbert Xu if (!src) 287412ca155SHerbert Xu /* frame comes from an external address */ 288412ca155SHerbert Xu macvlan_broadcast(skb, port, NULL, 289412ca155SHerbert Xu MACVLAN_MODE_PRIVATE | 290412ca155SHerbert Xu MACVLAN_MODE_VEPA | 291412ca155SHerbert Xu MACVLAN_MODE_PASSTHRU| 292412ca155SHerbert Xu MACVLAN_MODE_BRIDGE); 293412ca155SHerbert Xu else if (src->mode == MACVLAN_MODE_VEPA) 294412ca155SHerbert Xu /* flood to everyone except source */ 295412ca155SHerbert Xu macvlan_broadcast(skb, port, src->dev, 296412ca155SHerbert Xu MACVLAN_MODE_VEPA | 297412ca155SHerbert Xu MACVLAN_MODE_BRIDGE); 298412ca155SHerbert Xu else 299412ca155SHerbert Xu /* 300412ca155SHerbert Xu * flood only to VEPA ports, bridge ports 301412ca155SHerbert Xu * already saw the frame on the way out. 302412ca155SHerbert Xu */ 303412ca155SHerbert Xu macvlan_broadcast(skb, port, src->dev, 304412ca155SHerbert Xu MACVLAN_MODE_VEPA); 305412ca155SHerbert Xu 306412ca155SHerbert Xu rcu_read_unlock(); 307412ca155SHerbert Xu 308*260916dfSHerbert Xu if (src) 309*260916dfSHerbert Xu dev_put(src->dev); 310412ca155SHerbert Xu kfree_skb(skb); 311412ca155SHerbert Xu } 312412ca155SHerbert Xu } 313412ca155SHerbert Xu 314412ca155SHerbert Xu static void macvlan_broadcast_enqueue(struct macvlan_port *port, 315*260916dfSHerbert Xu const struct macvlan_dev *src, 316412ca155SHerbert Xu struct sk_buff *skb) 317412ca155SHerbert Xu { 318e676f197SHerbert Xu struct sk_buff *nskb; 319412ca155SHerbert Xu int err = -ENOMEM; 320412ca155SHerbert Xu 321e676f197SHerbert Xu nskb = skb_clone(skb, GFP_ATOMIC); 322e676f197SHerbert Xu if (!nskb) 323412ca155SHerbert Xu goto err; 324412ca155SHerbert Xu 325*260916dfSHerbert Xu MACVLAN_SKB_CB(nskb)->src = src; 326*260916dfSHerbert Xu 327412ca155SHerbert Xu spin_lock(&port->bc_queue.lock); 32807d92d5cSNicolas Dichtel if (skb_queue_len(&port->bc_queue) < MACVLAN_BC_QUEUE_LEN) { 329*260916dfSHerbert Xu if (src) 330*260916dfSHerbert Xu dev_hold(src->dev); 331e676f197SHerbert Xu __skb_queue_tail(&port->bc_queue, nskb); 332412ca155SHerbert Xu err = 0; 333412ca155SHerbert Xu } 334412ca155SHerbert Xu spin_unlock(&port->bc_queue.lock); 335412ca155SHerbert Xu 336412ca155SHerbert Xu if (err) 337e676f197SHerbert Xu goto free_nskb; 338412ca155SHerbert Xu 339412ca155SHerbert Xu schedule_work(&port->bc_work); 340412ca155SHerbert Xu return; 341412ca155SHerbert Xu 342e676f197SHerbert Xu free_nskb: 343e676f197SHerbert Xu kfree_skb(nskb); 344412ca155SHerbert Xu err: 345412ca155SHerbert Xu atomic_long_inc(&skb->dev->rx_dropped); 346412ca155SHerbert Xu } 347412ca155SHerbert Xu 34879cf79abSMichael Braun static void macvlan_flush_sources(struct macvlan_port *port, 34979cf79abSMichael Braun struct macvlan_dev *vlan) 35079cf79abSMichael Braun { 35179cf79abSMichael Braun int i; 35279cf79abSMichael Braun 35379cf79abSMichael Braun for (i = 0; i < MACVLAN_HASH_SIZE; i++) { 35479cf79abSMichael Braun struct hlist_node *h, *n; 35579cf79abSMichael Braun 35679cf79abSMichael Braun hlist_for_each_safe(h, n, &port->vlan_source_hash[i]) { 35779cf79abSMichael Braun struct macvlan_source_entry *entry; 35879cf79abSMichael Braun 35979cf79abSMichael Braun entry = hlist_entry(h, struct macvlan_source_entry, 36079cf79abSMichael Braun hlist); 36179cf79abSMichael Braun if (entry->vlan == vlan) 36279cf79abSMichael Braun macvlan_hash_del_source(entry); 36379cf79abSMichael Braun } 36479cf79abSMichael Braun } 36579cf79abSMichael Braun vlan->macaddr_count = 0; 36679cf79abSMichael Braun } 36779cf79abSMichael Braun 36879cf79abSMichael Braun static void macvlan_forward_source_one(struct sk_buff *skb, 36979cf79abSMichael Braun struct macvlan_dev *vlan) 37079cf79abSMichael Braun { 37179cf79abSMichael Braun struct sk_buff *nskb; 37279cf79abSMichael Braun struct net_device *dev; 37379cf79abSMichael Braun int len; 37479cf79abSMichael Braun int ret; 37579cf79abSMichael Braun 37679cf79abSMichael Braun dev = vlan->dev; 37779cf79abSMichael Braun if (unlikely(!(dev->flags & IFF_UP))) 37879cf79abSMichael Braun return; 37979cf79abSMichael Braun 38079cf79abSMichael Braun nskb = skb_clone(skb, GFP_ATOMIC); 38179cf79abSMichael Braun if (!nskb) 38279cf79abSMichael Braun return; 38379cf79abSMichael Braun 38479cf79abSMichael Braun len = nskb->len + ETH_HLEN; 38579cf79abSMichael Braun nskb->dev = dev; 38679cf79abSMichael Braun nskb->pkt_type = PACKET_HOST; 38779cf79abSMichael Braun 38879cf79abSMichael Braun ret = netif_rx(nskb); 3894c979935Sjbaron@akamai.com macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false); 39079cf79abSMichael Braun } 39179cf79abSMichael Braun 39279cf79abSMichael Braun static void macvlan_forward_source(struct sk_buff *skb, 39379cf79abSMichael Braun struct macvlan_port *port, 39479cf79abSMichael Braun const unsigned char *addr) 39579cf79abSMichael Braun { 39679cf79abSMichael Braun struct macvlan_source_entry *entry; 39779cf79abSMichael Braun u32 idx = macvlan_eth_hash(addr); 39879cf79abSMichael Braun struct hlist_head *h = &port->vlan_source_hash[idx]; 39979cf79abSMichael Braun 40079cf79abSMichael Braun hlist_for_each_entry_rcu(entry, h, hlist) { 40179cf79abSMichael Braun if (ether_addr_equal_64bits(entry->addr, addr)) 40279cf79abSMichael Braun if (entry->vlan->dev->flags & IFF_UP) 40379cf79abSMichael Braun macvlan_forward_source_one(skb, entry->vlan); 40479cf79abSMichael Braun } 40579cf79abSMichael Braun } 40679cf79abSMichael Braun 407b863ceb7SPatrick McHardy /* called under rcu_read_lock() from netif_receive_skb */ 4088a4eb573SJiri Pirko static rx_handler_result_t macvlan_handle_frame(struct sk_buff **pskb) 409b863ceb7SPatrick McHardy { 410ab95bfe0SJiri Pirko struct macvlan_port *port; 4118a4eb573SJiri Pirko struct sk_buff *skb = *pskb; 412b863ceb7SPatrick McHardy const struct ethhdr *eth = eth_hdr(skb); 413b863ceb7SPatrick McHardy const struct macvlan_dev *vlan; 414618e1b74SArnd Bergmann const struct macvlan_dev *src; 415b863ceb7SPatrick McHardy struct net_device *dev; 416ba01877fSSridhar Samudrala unsigned int len = 0; 417d1dd9119Sjbaron@akamai.com int ret; 418d1dd9119Sjbaron@akamai.com rx_handler_result_t handle_res; 419b863ceb7SPatrick McHardy 420a35e2c1bSJiri Pirko port = macvlan_port_get_rcu(skb->dev); 421b863ceb7SPatrick McHardy if (is_multicast_ether_addr(eth->h_dest)) { 42219bcf9f2SEric W. Biederman skb = ip_check_defrag(dev_net(skb->dev), skb, IP_DEFRAG_MACVLAN); 423bc416d97SEric Dumazet if (!skb) 424bc416d97SEric Dumazet return RX_HANDLER_CONSUMED; 425e639b8d8SSabrina Dubroca *pskb = skb; 4264ec7ac12SEric Dumazet eth = eth_hdr(skb); 42779cf79abSMichael Braun macvlan_forward_source(skb, port, eth->h_source); 428618e1b74SArnd Bergmann src = macvlan_hash_lookup(port, eth->h_source); 429412ca155SHerbert Xu if (src && src->mode != MACVLAN_MODE_VEPA && 430412ca155SHerbert Xu src->mode != MACVLAN_MODE_BRIDGE) { 431729e72a1Sstephen hemminger /* forward to original port. */ 432729e72a1Sstephen hemminger vlan = src; 433412ca155SHerbert Xu ret = macvlan_broadcast_one(skb, vlan, eth, 0) ?: 434412ca155SHerbert Xu netif_rx(skb); 435d1dd9119Sjbaron@akamai.com handle_res = RX_HANDLER_CONSUMED; 436729e72a1Sstephen hemminger goto out; 437729e72a1Sstephen hemminger } 438729e72a1Sstephen hemminger 439*260916dfSHerbert Xu macvlan_broadcast_enqueue(port, src, skb); 440412ca155SHerbert Xu 4418a4eb573SJiri Pirko return RX_HANDLER_PASS; 442b863ceb7SPatrick McHardy } 443b863ceb7SPatrick McHardy 44479cf79abSMichael Braun macvlan_forward_source(skb, port, eth->h_source); 445eb06acdcSSridhar Samudrala if (port->passthru) 446233c7df0SJiri Pirko vlan = list_first_or_null_rcu(&port->vlans, 447233c7df0SJiri Pirko struct macvlan_dev, list); 448eb06acdcSSridhar Samudrala else 449b863ceb7SPatrick McHardy vlan = macvlan_hash_lookup(port, eth->h_dest); 450b863ceb7SPatrick McHardy if (vlan == NULL) 4518a4eb573SJiri Pirko return RX_HANDLER_PASS; 452b863ceb7SPatrick McHardy 453b863ceb7SPatrick McHardy dev = vlan->dev; 454b863ceb7SPatrick McHardy if (unlikely(!(dev->flags & IFF_UP))) { 455b863ceb7SPatrick McHardy kfree_skb(skb); 4568a4eb573SJiri Pirko return RX_HANDLER_CONSUMED; 457b863ceb7SPatrick McHardy } 458a1e514c5SArnd Bergmann len = skb->len + ETH_HLEN; 459b863ceb7SPatrick McHardy skb = skb_share_check(skb, GFP_ATOMIC); 460d1dd9119Sjbaron@akamai.com if (!skb) { 461d1dd9119Sjbaron@akamai.com ret = NET_RX_DROP; 462d1dd9119Sjbaron@akamai.com handle_res = RX_HANDLER_CONSUMED; 463ba01877fSSridhar Samudrala goto out; 464d1dd9119Sjbaron@akamai.com } 465b863ceb7SPatrick McHardy 466e639b8d8SSabrina Dubroca *pskb = skb; 467b863ceb7SPatrick McHardy skb->dev = dev; 468b863ceb7SPatrick McHardy skb->pkt_type = PACKET_HOST; 469b863ceb7SPatrick McHardy 470d1dd9119Sjbaron@akamai.com ret = NET_RX_SUCCESS; 471d1dd9119Sjbaron@akamai.com handle_res = RX_HANDLER_ANOTHER; 472ba01877fSSridhar Samudrala out: 4734c979935Sjbaron@akamai.com macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, false); 474d1dd9119Sjbaron@akamai.com return handle_res; 475b863ceb7SPatrick McHardy } 476b863ceb7SPatrick McHardy 477618e1b74SArnd Bergmann static int macvlan_queue_xmit(struct sk_buff *skb, struct net_device *dev) 478618e1b74SArnd Bergmann { 479618e1b74SArnd Bergmann const struct macvlan_dev *vlan = netdev_priv(dev); 480618e1b74SArnd Bergmann const struct macvlan_port *port = vlan->port; 481618e1b74SArnd Bergmann const struct macvlan_dev *dest; 482618e1b74SArnd Bergmann 483618e1b74SArnd Bergmann if (vlan->mode == MACVLAN_MODE_BRIDGE) { 484618e1b74SArnd Bergmann const struct ethhdr *eth = (void *)skb->data; 485618e1b74SArnd Bergmann 486618e1b74SArnd Bergmann /* send to other bridge ports directly */ 487618e1b74SArnd Bergmann if (is_multicast_ether_addr(eth->h_dest)) { 488618e1b74SArnd Bergmann macvlan_broadcast(skb, port, dev, MACVLAN_MODE_BRIDGE); 489618e1b74SArnd Bergmann goto xmit_world; 490618e1b74SArnd Bergmann } 491618e1b74SArnd Bergmann 492618e1b74SArnd Bergmann dest = macvlan_hash_lookup(port, eth->h_dest); 493618e1b74SArnd Bergmann if (dest && dest->mode == MACVLAN_MODE_BRIDGE) { 494a37dd333SDavid Ward /* send to lowerdev first for its network taps */ 495cb2d0f3eSDavid Ward dev_forward_skb(vlan->lowerdev, skb); 496618e1b74SArnd Bergmann 497618e1b74SArnd Bergmann return NET_XMIT_SUCCESS; 498618e1b74SArnd Bergmann } 499618e1b74SArnd Bergmann } 500618e1b74SArnd Bergmann 501618e1b74SArnd Bergmann xmit_world: 50259b9997bSDavid S. Miller skb->dev = vlan->lowerdev; 503618e1b74SArnd Bergmann return dev_queue_xmit(skb); 504618e1b74SArnd Bergmann } 505618e1b74SArnd Bergmann 506688cea83Sdingtianhong static inline netdev_tx_t macvlan_netpoll_send_skb(struct macvlan_dev *vlan, struct sk_buff *skb) 507688cea83Sdingtianhong { 508688cea83Sdingtianhong #ifdef CONFIG_NET_POLL_CONTROLLER 509688cea83Sdingtianhong if (vlan->netpoll) 510688cea83Sdingtianhong netpoll_send_skb(vlan->netpoll, skb); 511688cea83Sdingtianhong #else 512688cea83Sdingtianhong BUG(); 513688cea83Sdingtianhong #endif 514688cea83Sdingtianhong return NETDEV_TX_OK; 515688cea83Sdingtianhong } 516688cea83Sdingtianhong 5170db901bdSstephen hemminger static netdev_tx_t macvlan_start_xmit(struct sk_buff *skb, 518424efe9cSStephen Hemminger struct net_device *dev) 519b863ceb7SPatrick McHardy { 520b863ceb7SPatrick McHardy unsigned int len = skb->len; 521b863ceb7SPatrick McHardy int ret; 522688cea83Sdingtianhong struct macvlan_dev *vlan = netdev_priv(dev); 523688cea83Sdingtianhong 524688cea83Sdingtianhong if (unlikely(netpoll_tx_running(dev))) 525688cea83Sdingtianhong return macvlan_netpoll_send_skb(vlan, skb); 526b863ceb7SPatrick McHardy 527a6cc0cfaSJohn Fastabend if (vlan->fwd_priv) { 528a6cc0cfaSJohn Fastabend skb->dev = vlan->lowerdev; 529f663dd9aSJason Wang ret = dev_queue_xmit_accel(skb, vlan->fwd_priv); 530a6cc0cfaSJohn Fastabend } else { 531618e1b74SArnd Bergmann ret = macvlan_queue_xmit(skb, dev); 532a6cc0cfaSJohn Fastabend } 533a6cc0cfaSJohn Fastabend 5342d6c9ffcSEric Dumazet if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) { 535cdf3e274SLi RongQing struct vlan_pcpu_stats *pcpu_stats; 5362c114553SEric Dumazet 5378ffab51bSEric Dumazet pcpu_stats = this_cpu_ptr(vlan->pcpu_stats); 5388ffab51bSEric Dumazet u64_stats_update_begin(&pcpu_stats->syncp); 5398ffab51bSEric Dumazet pcpu_stats->tx_packets++; 5408ffab51bSEric Dumazet pcpu_stats->tx_bytes += len; 5418ffab51bSEric Dumazet u64_stats_update_end(&pcpu_stats->syncp); 5428ffab51bSEric Dumazet } else { 5438ffab51bSEric Dumazet this_cpu_inc(vlan->pcpu_stats->tx_dropped); 5448ffab51bSEric Dumazet } 545cbbef5e1SPatrick McHardy return ret; 546b863ceb7SPatrick McHardy } 547b863ceb7SPatrick McHardy 548b863ceb7SPatrick McHardy static int macvlan_hard_header(struct sk_buff *skb, struct net_device *dev, 5493b04dddeSStephen Hemminger unsigned short type, const void *daddr, 5503b04dddeSStephen Hemminger const void *saddr, unsigned len) 551b863ceb7SPatrick McHardy { 552b863ceb7SPatrick McHardy const struct macvlan_dev *vlan = netdev_priv(dev); 553b863ceb7SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev; 554b863ceb7SPatrick McHardy 5550c4e8581SStephen Hemminger return dev_hard_header(skb, lowerdev, type, daddr, 556b863ceb7SPatrick McHardy saddr ? : dev->dev_addr, len); 557b863ceb7SPatrick McHardy } 558b863ceb7SPatrick McHardy 5593b04dddeSStephen Hemminger static const struct header_ops macvlan_hard_header_ops = { 5603b04dddeSStephen Hemminger .create = macvlan_hard_header, 5613b04dddeSStephen Hemminger .parse = eth_header_parse, 5623b04dddeSStephen Hemminger .cache = eth_header_cache, 5633b04dddeSStephen Hemminger .cache_update = eth_header_cache_update, 5643b04dddeSStephen Hemminger }; 5653b04dddeSStephen Hemminger 566b13ba1b8SJason Wang static struct rtnl_link_ops macvlan_link_ops; 567b13ba1b8SJason Wang 568b863ceb7SPatrick McHardy static int macvlan_open(struct net_device *dev) 569b863ceb7SPatrick McHardy { 570b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev); 571b863ceb7SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev; 572b863ceb7SPatrick McHardy int err; 573b863ceb7SPatrick McHardy 574eb06acdcSSridhar Samudrala if (vlan->port->passthru) { 57578738141SMichael S. Tsirkin if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC)) { 57678738141SMichael S. Tsirkin err = dev_set_promiscuity(lowerdev, 1); 57778738141SMichael S. Tsirkin if (err < 0) 57878738141SMichael S. Tsirkin goto out; 57978738141SMichael S. Tsirkin } 580eb06acdcSSridhar Samudrala goto hash_add; 581eb06acdcSSridhar Samudrala } 582eb06acdcSSridhar Samudrala 583b13ba1b8SJason Wang if (lowerdev->features & NETIF_F_HW_L2FW_DOFFLOAD && 584b13ba1b8SJason Wang dev->rtnl_link_ops == &macvlan_link_ops) { 585a6cc0cfaSJohn Fastabend vlan->fwd_priv = 586a6cc0cfaSJohn Fastabend lowerdev->netdev_ops->ndo_dfwd_add_station(lowerdev, dev); 587a6cc0cfaSJohn Fastabend 588a6cc0cfaSJohn Fastabend /* If we get a NULL pointer back, or if we get an error 589a6cc0cfaSJohn Fastabend * then we should just fall through to the non accelerated path 590a6cc0cfaSJohn Fastabend */ 591a6cc0cfaSJohn Fastabend if (IS_ERR_OR_NULL(vlan->fwd_priv)) { 592a6cc0cfaSJohn Fastabend vlan->fwd_priv = NULL; 593f663dd9aSJason Wang } else 594a6cc0cfaSJohn Fastabend return 0; 595a6cc0cfaSJohn Fastabend } 596a6cc0cfaSJohn Fastabend 597f9ac30f0SEric Biederman err = -EBUSY; 598f9ac30f0SEric Biederman if (macvlan_addr_busy(vlan->port, dev->dev_addr)) 599f9ac30f0SEric Biederman goto out; 600f9ac30f0SEric Biederman 601a748ee24SJiri Pirko err = dev_uc_add(lowerdev, dev->dev_addr); 602b863ceb7SPatrick McHardy if (err < 0) 603b89fb7daSWang Chen goto out; 604b89fb7daSWang Chen if (dev->flags & IFF_ALLMULTI) { 605b89fb7daSWang Chen err = dev_set_allmulti(lowerdev, 1); 606b89fb7daSWang Chen if (err < 0) 607b89fb7daSWang Chen goto del_unicast; 608b89fb7daSWang Chen } 609eb06acdcSSridhar Samudrala 610efdbd2b3SVlad Yasevich if (dev->flags & IFF_PROMISC) { 611efdbd2b3SVlad Yasevich err = dev_set_promiscuity(lowerdev, 1); 612efdbd2b3SVlad Yasevich if (err < 0) 613efdbd2b3SVlad Yasevich goto clear_multi; 614efdbd2b3SVlad Yasevich } 615efdbd2b3SVlad Yasevich 616eb06acdcSSridhar Samudrala hash_add: 617f9ac30f0SEric Biederman macvlan_hash_add(vlan); 618b863ceb7SPatrick McHardy return 0; 619b89fb7daSWang Chen 620efdbd2b3SVlad Yasevich clear_multi: 621efdbd2b3SVlad Yasevich dev_set_allmulti(lowerdev, -1); 622b89fb7daSWang Chen del_unicast: 623a748ee24SJiri Pirko dev_uc_del(lowerdev, dev->dev_addr); 624b89fb7daSWang Chen out: 625a6cc0cfaSJohn Fastabend if (vlan->fwd_priv) { 626a6cc0cfaSJohn Fastabend lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev, 627a6cc0cfaSJohn Fastabend vlan->fwd_priv); 628a6cc0cfaSJohn Fastabend vlan->fwd_priv = NULL; 629a6cc0cfaSJohn Fastabend } 630b89fb7daSWang Chen return err; 631b863ceb7SPatrick McHardy } 632b863ceb7SPatrick McHardy 633b863ceb7SPatrick McHardy static int macvlan_stop(struct net_device *dev) 634b863ceb7SPatrick McHardy { 635b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev); 636b863ceb7SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev; 637b863ceb7SPatrick McHardy 638a6cc0cfaSJohn Fastabend if (vlan->fwd_priv) { 639a6cc0cfaSJohn Fastabend lowerdev->netdev_ops->ndo_dfwd_del_station(lowerdev, 640a6cc0cfaSJohn Fastabend vlan->fwd_priv); 641a6cc0cfaSJohn Fastabend vlan->fwd_priv = NULL; 642a6cc0cfaSJohn Fastabend return 0; 643a6cc0cfaSJohn Fastabend } 644a6cc0cfaSJohn Fastabend 645df8ef8f3SJohn Fastabend dev_uc_unsync(lowerdev, dev); 646df8ef8f3SJohn Fastabend dev_mc_unsync(lowerdev, dev); 647df8ef8f3SJohn Fastabend 648eb06acdcSSridhar Samudrala if (vlan->port->passthru) { 649df8ef8f3SJohn Fastabend if (!(vlan->flags & MACVLAN_FLAG_NOPROMISC)) 650eb06acdcSSridhar Samudrala dev_set_promiscuity(lowerdev, -1); 651eb06acdcSSridhar Samudrala goto hash_del; 652eb06acdcSSridhar Samudrala } 653eb06acdcSSridhar Samudrala 654b863ceb7SPatrick McHardy if (dev->flags & IFF_ALLMULTI) 655b863ceb7SPatrick McHardy dev_set_allmulti(lowerdev, -1); 656b863ceb7SPatrick McHardy 657efdbd2b3SVlad Yasevich if (dev->flags & IFF_PROMISC) 658efdbd2b3SVlad Yasevich dev_set_promiscuity(lowerdev, -1); 659efdbd2b3SVlad Yasevich 660a748ee24SJiri Pirko dev_uc_del(lowerdev, dev->dev_addr); 661b863ceb7SPatrick McHardy 662eb06acdcSSridhar Samudrala hash_del: 663449f4544SEric Dumazet macvlan_hash_del(vlan, !dev->dismantle); 664b863ceb7SPatrick McHardy return 0; 665b863ceb7SPatrick McHardy } 666b863ceb7SPatrick McHardy 667e289fd28Sdingtianhong static int macvlan_sync_address(struct net_device *dev, unsigned char *addr) 668ad5d20a6SPatrick McHardy { 669ad5d20a6SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev); 670ad5d20a6SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev; 671ad5d20a6SPatrick McHardy int err; 672ad5d20a6SPatrick McHardy 673f9ac30f0SEric Biederman if (!(dev->flags & IFF_UP)) { 674f9ac30f0SEric Biederman /* Just copy in the new address */ 675e289fd28Sdingtianhong ether_addr_copy(dev->dev_addr, addr); 676f9ac30f0SEric Biederman } else { 677f9ac30f0SEric Biederman /* Rehash and update the device filters */ 678e289fd28Sdingtianhong if (macvlan_addr_busy(vlan->port, addr)) 679f9ac30f0SEric Biederman return -EBUSY; 680ad5d20a6SPatrick McHardy 681e289fd28Sdingtianhong if (!vlan->port->passthru) { 682e289fd28Sdingtianhong err = dev_uc_add(lowerdev, addr); 683ccffad25SJiri Pirko if (err) 684ad5d20a6SPatrick McHardy return err; 685f9ac30f0SEric Biederman 686a748ee24SJiri Pirko dev_uc_del(lowerdev, dev->dev_addr); 687e289fd28Sdingtianhong } 688ad5d20a6SPatrick McHardy 689e289fd28Sdingtianhong macvlan_hash_change_addr(vlan, addr); 690f9ac30f0SEric Biederman } 691ad5d20a6SPatrick McHardy return 0; 692ad5d20a6SPatrick McHardy } 693ad5d20a6SPatrick McHardy 694e289fd28Sdingtianhong static int macvlan_set_mac_address(struct net_device *dev, void *p) 695e289fd28Sdingtianhong { 696e289fd28Sdingtianhong struct macvlan_dev *vlan = netdev_priv(dev); 697e289fd28Sdingtianhong struct sockaddr *addr = p; 698e289fd28Sdingtianhong 699e289fd28Sdingtianhong if (!is_valid_ether_addr(addr->sa_data)) 700e289fd28Sdingtianhong return -EADDRNOTAVAIL; 701e289fd28Sdingtianhong 702e289fd28Sdingtianhong if (vlan->mode == MACVLAN_MODE_PASSTHRU) { 703e289fd28Sdingtianhong dev_set_mac_address(vlan->lowerdev, addr); 704e289fd28Sdingtianhong return 0; 705e289fd28Sdingtianhong } 706e289fd28Sdingtianhong 707e289fd28Sdingtianhong return macvlan_sync_address(dev, addr->sa_data); 708e289fd28Sdingtianhong } 709e289fd28Sdingtianhong 710b863ceb7SPatrick McHardy static void macvlan_change_rx_flags(struct net_device *dev, int change) 711b863ceb7SPatrick McHardy { 712b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev); 713b863ceb7SPatrick McHardy struct net_device *lowerdev = vlan->lowerdev; 714b863ceb7SPatrick McHardy 715bbeb0eadSPeter Christensen if (dev->flags & IFF_UP) { 716b863ceb7SPatrick McHardy if (change & IFF_ALLMULTI) 717b863ceb7SPatrick McHardy dev_set_allmulti(lowerdev, dev->flags & IFF_ALLMULTI ? 1 : -1); 718efdbd2b3SVlad Yasevich if (change & IFF_PROMISC) 719efdbd2b3SVlad Yasevich dev_set_promiscuity(lowerdev, 720efdbd2b3SVlad Yasevich dev->flags & IFF_PROMISC ? 1 : -1); 721efdbd2b3SVlad Yasevich 722b863ceb7SPatrick McHardy } 723bbeb0eadSPeter Christensen } 724b863ceb7SPatrick McHardy 725df8ef8f3SJohn Fastabend static void macvlan_set_mac_lists(struct net_device *dev) 726b863ceb7SPatrick McHardy { 727b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev); 728b863ceb7SPatrick McHardy 729cd431e73SEric Dumazet if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) { 730cd431e73SEric Dumazet bitmap_fill(vlan->mc_filter, MACVLAN_MC_FILTER_SZ); 731cd431e73SEric Dumazet } else { 732cd431e73SEric Dumazet struct netdev_hw_addr *ha; 733cd431e73SEric Dumazet DECLARE_BITMAP(filter, MACVLAN_MC_FILTER_SZ); 734cd431e73SEric Dumazet 735cd431e73SEric Dumazet bitmap_zero(filter, MACVLAN_MC_FILTER_SZ); 736cd431e73SEric Dumazet netdev_for_each_mc_addr(ha, dev) { 7373807ff58SEric Dumazet __set_bit(mc_hash(vlan, ha->addr), filter); 738cd431e73SEric Dumazet } 739d5270430SEric Dumazet 7403807ff58SEric Dumazet __set_bit(mc_hash(vlan, dev->broadcast), filter); 741d5270430SEric Dumazet 742cd431e73SEric Dumazet bitmap_copy(vlan->mc_filter, filter, MACVLAN_MC_FILTER_SZ); 743cd431e73SEric Dumazet } 744df8ef8f3SJohn Fastabend dev_uc_sync(vlan->lowerdev, dev); 745b863ceb7SPatrick McHardy dev_mc_sync(vlan->lowerdev, dev); 746b863ceb7SPatrick McHardy } 747b863ceb7SPatrick McHardy 748b863ceb7SPatrick McHardy static int macvlan_change_mtu(struct net_device *dev, int new_mtu) 749b863ceb7SPatrick McHardy { 750b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev); 751b863ceb7SPatrick McHardy 752b863ceb7SPatrick McHardy if (new_mtu < 68 || vlan->lowerdev->mtu < new_mtu) 753b863ceb7SPatrick McHardy return -EINVAL; 754b863ceb7SPatrick McHardy dev->mtu = new_mtu; 755b863ceb7SPatrick McHardy return 0; 756b863ceb7SPatrick McHardy } 757b863ceb7SPatrick McHardy 758b863ceb7SPatrick McHardy /* 759b863ceb7SPatrick McHardy * macvlan network devices have devices nesting below it and are a special 760b863ceb7SPatrick McHardy * "super class" of normal network devices; split their locks off into a 761b863ceb7SPatrick McHardy * separate class since they always nest. 762b863ceb7SPatrick McHardy */ 763b863ceb7SPatrick McHardy static struct lock_class_key macvlan_netdev_xmit_lock_key; 764cf508b12SDavid S. Miller static struct lock_class_key macvlan_netdev_addr_lock_key; 765b863ceb7SPatrick McHardy 7668b4703e9SVlad Yasevich #define ALWAYS_ON_FEATURES \ 767c8cd0989STom Herbert (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_GSO_SOFTWARE | NETIF_F_LLTX | \ 768a523a5ecSJason Wang NETIF_F_GSO_ROBUST) 7698b4703e9SVlad Yasevich 770b863ceb7SPatrick McHardy #define MACVLAN_FEATURES \ 771a188222bSTom Herbert (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \ 77262dbe830SMichal Kubeček NETIF_F_GSO | NETIF_F_TSO | NETIF_F_UFO | NETIF_F_LRO | \ 7738d13e670SJohn Fastabend NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \ 77428d2b136SPatrick McHardy NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER) 775b863ceb7SPatrick McHardy 776b863ceb7SPatrick McHardy #define MACVLAN_STATE_MASK \ 777b863ceb7SPatrick McHardy ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT)) 778b863ceb7SPatrick McHardy 779c674ac30SVlad Yasevich static int macvlan_get_nest_level(struct net_device *dev) 780c674ac30SVlad Yasevich { 781c674ac30SVlad Yasevich return ((struct macvlan_dev *)netdev_priv(dev))->nest_level; 782c674ac30SVlad Yasevich } 783c674ac30SVlad Yasevich 784e8a0464cSDavid S. Miller static void macvlan_set_lockdep_class_one(struct net_device *dev, 785e8a0464cSDavid S. Miller struct netdev_queue *txq, 786e8a0464cSDavid S. Miller void *_unused) 787c773e847SDavid S. Miller { 788c773e847SDavid S. Miller lockdep_set_class(&txq->_xmit_lock, 789c773e847SDavid S. Miller &macvlan_netdev_xmit_lock_key); 790c773e847SDavid S. Miller } 791c773e847SDavid S. Miller 792c773e847SDavid S. Miller static void macvlan_set_lockdep_class(struct net_device *dev) 793c773e847SDavid S. Miller { 794c674ac30SVlad Yasevich lockdep_set_class_and_subclass(&dev->addr_list_lock, 795c674ac30SVlad Yasevich &macvlan_netdev_addr_lock_key, 796c674ac30SVlad Yasevich macvlan_get_nest_level(dev)); 797e8a0464cSDavid S. Miller netdev_for_each_tx_queue(dev, macvlan_set_lockdep_class_one, NULL); 798c773e847SDavid S. Miller } 799c773e847SDavid S. Miller 800b863ceb7SPatrick McHardy static int macvlan_init(struct net_device *dev) 801b863ceb7SPatrick McHardy { 802b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev); 803b863ceb7SPatrick McHardy const struct net_device *lowerdev = vlan->lowerdev; 80430837960SFrancesco Ruggeri struct macvlan_port *port = vlan->port; 805b863ceb7SPatrick McHardy 806b863ceb7SPatrick McHardy dev->state = (dev->state & ~MACVLAN_STATE_MASK) | 807b863ceb7SPatrick McHardy (lowerdev->state & MACVLAN_STATE_MASK); 808b863ceb7SPatrick McHardy dev->features = lowerdev->features & MACVLAN_FEATURES; 8098b4703e9SVlad Yasevich dev->features |= ALWAYS_ON_FEATURES; 81062dbe830SMichal Kubeček dev->hw_features |= NETIF_F_LRO; 811081e83a7SVlad Yasevich dev->vlan_features = lowerdev->vlan_features & MACVLAN_FEATURES; 8128c2acc53SPatrick McHardy dev->gso_max_size = lowerdev->gso_max_size; 813f6773c5eSEric Dumazet dev->gso_max_segs = lowerdev->gso_max_segs; 814ef5c8996Ssg.tweak@gmail.com dev->hard_header_len = lowerdev->hard_header_len; 815b863ceb7SPatrick McHardy 816c773e847SDavid S. Miller macvlan_set_lockdep_class(dev); 817c773e847SDavid S. Miller 8181c213bd2SWANG Cong vlan->pcpu_stats = netdev_alloc_pcpu_stats(struct vlan_pcpu_stats); 8198ffab51bSEric Dumazet if (!vlan->pcpu_stats) 820fccaf710SEric Dumazet return -ENOMEM; 821fccaf710SEric Dumazet 82230837960SFrancesco Ruggeri port->count += 1; 82330837960SFrancesco Ruggeri 824b863ceb7SPatrick McHardy return 0; 825b863ceb7SPatrick McHardy } 826b863ceb7SPatrick McHardy 827fccaf710SEric Dumazet static void macvlan_uninit(struct net_device *dev) 828fccaf710SEric Dumazet { 829fccaf710SEric Dumazet struct macvlan_dev *vlan = netdev_priv(dev); 830d5cd9244SEric W. Biederman struct macvlan_port *port = vlan->port; 831fccaf710SEric Dumazet 8328ffab51bSEric Dumazet free_percpu(vlan->pcpu_stats); 833d5cd9244SEric W. Biederman 83479cf79abSMichael Braun macvlan_flush_sources(port, vlan); 8355e3c516bSDavid S. Miller port->count -= 1; 8365e3c516bSDavid S. Miller if (!port->count) 837d5cd9244SEric W. Biederman macvlan_port_destroy(port->dev); 838fccaf710SEric Dumazet } 839fccaf710SEric Dumazet 84028172739SEric Dumazet static struct rtnl_link_stats64 *macvlan_dev_get_stats64(struct net_device *dev, 84128172739SEric Dumazet struct rtnl_link_stats64 *stats) 842fccaf710SEric Dumazet { 843fccaf710SEric Dumazet struct macvlan_dev *vlan = netdev_priv(dev); 844fccaf710SEric Dumazet 8458ffab51bSEric Dumazet if (vlan->pcpu_stats) { 846cdf3e274SLi RongQing struct vlan_pcpu_stats *p; 8478ffab51bSEric Dumazet u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes; 8488ffab51bSEric Dumazet u32 rx_errors = 0, tx_dropped = 0; 849bc66154eSEric Dumazet unsigned int start; 850fccaf710SEric Dumazet int i; 851fccaf710SEric Dumazet 852fccaf710SEric Dumazet for_each_possible_cpu(i) { 8538ffab51bSEric Dumazet p = per_cpu_ptr(vlan->pcpu_stats, i); 854bc66154eSEric Dumazet do { 85557a7744eSEric W. Biederman start = u64_stats_fetch_begin_irq(&p->syncp); 856bc66154eSEric Dumazet rx_packets = p->rx_packets; 857bc66154eSEric Dumazet rx_bytes = p->rx_bytes; 858bc66154eSEric Dumazet rx_multicast = p->rx_multicast; 8598ffab51bSEric Dumazet tx_packets = p->tx_packets; 8608ffab51bSEric Dumazet tx_bytes = p->tx_bytes; 86157a7744eSEric W. Biederman } while (u64_stats_fetch_retry_irq(&p->syncp, start)); 8628ffab51bSEric Dumazet 8638ffab51bSEric Dumazet stats->rx_packets += rx_packets; 8648ffab51bSEric Dumazet stats->rx_bytes += rx_bytes; 8658ffab51bSEric Dumazet stats->multicast += rx_multicast; 8668ffab51bSEric Dumazet stats->tx_packets += tx_packets; 8678ffab51bSEric Dumazet stats->tx_bytes += tx_bytes; 8688ffab51bSEric Dumazet /* rx_errors & tx_dropped are u32, updated 8698ffab51bSEric Dumazet * without syncp protection. 8708ffab51bSEric Dumazet */ 8718ffab51bSEric Dumazet rx_errors += p->rx_errors; 8728ffab51bSEric Dumazet tx_dropped += p->tx_dropped; 873fccaf710SEric Dumazet } 8748ffab51bSEric Dumazet stats->rx_errors = rx_errors; 8758ffab51bSEric Dumazet stats->rx_dropped = rx_errors; 8768ffab51bSEric Dumazet stats->tx_dropped = tx_dropped; 877fccaf710SEric Dumazet } 878fccaf710SEric Dumazet return stats; 879fccaf710SEric Dumazet } 880fccaf710SEric Dumazet 8818e586137SJiri Pirko static int macvlan_vlan_rx_add_vid(struct net_device *dev, 88280d5c368SPatrick McHardy __be16 proto, u16 vid) 8838d13e670SJohn Fastabend { 8848d13e670SJohn Fastabend struct macvlan_dev *vlan = netdev_priv(dev); 8858d13e670SJohn Fastabend struct net_device *lowerdev = vlan->lowerdev; 8868d13e670SJohn Fastabend 88780d5c368SPatrick McHardy return vlan_vid_add(lowerdev, proto, vid); 8888d13e670SJohn Fastabend } 8898d13e670SJohn Fastabend 8908e586137SJiri Pirko static int macvlan_vlan_rx_kill_vid(struct net_device *dev, 89180d5c368SPatrick McHardy __be16 proto, u16 vid) 8928d13e670SJohn Fastabend { 8938d13e670SJohn Fastabend struct macvlan_dev *vlan = netdev_priv(dev); 8948d13e670SJohn Fastabend struct net_device *lowerdev = vlan->lowerdev; 8958d13e670SJohn Fastabend 89680d5c368SPatrick McHardy vlan_vid_del(lowerdev, proto, vid); 8978e586137SJiri Pirko return 0; 8988d13e670SJohn Fastabend } 8998d13e670SJohn Fastabend 900edc7d573Sstephen hemminger static int macvlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[], 901df8ef8f3SJohn Fastabend struct net_device *dev, 902f6f6424bSJiri Pirko const unsigned char *addr, u16 vid, 903df8ef8f3SJohn Fastabend u16 flags) 904df8ef8f3SJohn Fastabend { 905df8ef8f3SJohn Fastabend struct macvlan_dev *vlan = netdev_priv(dev); 906df8ef8f3SJohn Fastabend int err = -EINVAL; 907df8ef8f3SJohn Fastabend 9088a50f11cSVlad Yasevich /* Support unicast filter only on passthru devices. 9098a50f11cSVlad Yasevich * Multicast filter should be allowed on all devices. 9108a50f11cSVlad Yasevich */ 9118a50f11cSVlad Yasevich if (!vlan->port->passthru && is_unicast_ether_addr(addr)) 912df8ef8f3SJohn Fastabend return -EOPNOTSUPP; 913df8ef8f3SJohn Fastabend 914ab2cfbb2SThomas Richter if (flags & NLM_F_REPLACE) 915ab2cfbb2SThomas Richter return -EOPNOTSUPP; 916ab2cfbb2SThomas Richter 917df8ef8f3SJohn Fastabend if (is_unicast_ether_addr(addr)) 918df8ef8f3SJohn Fastabend err = dev_uc_add_excl(dev, addr); 919df8ef8f3SJohn Fastabend else if (is_multicast_ether_addr(addr)) 920df8ef8f3SJohn Fastabend err = dev_mc_add_excl(dev, addr); 921df8ef8f3SJohn Fastabend 922df8ef8f3SJohn Fastabend return err; 923df8ef8f3SJohn Fastabend } 924df8ef8f3SJohn Fastabend 9251690be63SVlad Yasevich static int macvlan_fdb_del(struct ndmsg *ndm, struct nlattr *tb[], 926df8ef8f3SJohn Fastabend struct net_device *dev, 927f6f6424bSJiri Pirko const unsigned char *addr, u16 vid) 928df8ef8f3SJohn Fastabend { 929df8ef8f3SJohn Fastabend struct macvlan_dev *vlan = netdev_priv(dev); 930df8ef8f3SJohn Fastabend int err = -EINVAL; 931df8ef8f3SJohn Fastabend 9328a50f11cSVlad Yasevich /* Support unicast filter only on passthru devices. 9338a50f11cSVlad Yasevich * Multicast filter should be allowed on all devices. 9348a50f11cSVlad Yasevich */ 9358a50f11cSVlad Yasevich if (!vlan->port->passthru && is_unicast_ether_addr(addr)) 936df8ef8f3SJohn Fastabend return -EOPNOTSUPP; 937df8ef8f3SJohn Fastabend 938df8ef8f3SJohn Fastabend if (is_unicast_ether_addr(addr)) 939df8ef8f3SJohn Fastabend err = dev_uc_del(dev, addr); 940df8ef8f3SJohn Fastabend else if (is_multicast_ether_addr(addr)) 941df8ef8f3SJohn Fastabend err = dev_mc_del(dev, addr); 942df8ef8f3SJohn Fastabend 943df8ef8f3SJohn Fastabend return err; 944df8ef8f3SJohn Fastabend } 945df8ef8f3SJohn Fastabend 946b863ceb7SPatrick McHardy static void macvlan_ethtool_get_drvinfo(struct net_device *dev, 947b863ceb7SPatrick McHardy struct ethtool_drvinfo *drvinfo) 948b863ceb7SPatrick McHardy { 9497826d43fSJiri Pirko strlcpy(drvinfo->driver, "macvlan", sizeof(drvinfo->driver)); 9507826d43fSJiri Pirko strlcpy(drvinfo->version, "0.1", sizeof(drvinfo->version)); 951b863ceb7SPatrick McHardy } 952b863ceb7SPatrick McHardy 95385f95819SDavid Decotigny static int macvlan_ethtool_get_link_ksettings(struct net_device *dev, 95485f95819SDavid Decotigny struct ethtool_link_ksettings *cmd) 9559edb8bb6SStephen Hemminger { 9569edb8bb6SStephen Hemminger const struct macvlan_dev *vlan = netdev_priv(dev); 9574bc71cb9SJiri Pirko 95885f95819SDavid Decotigny return __ethtool_get_link_ksettings(vlan->lowerdev, cmd); 9599edb8bb6SStephen Hemminger } 9609edb8bb6SStephen Hemminger 9612be5c767SVlad Yasevich static netdev_features_t macvlan_fix_features(struct net_device *dev, 9622be5c767SVlad Yasevich netdev_features_t features) 9632be5c767SVlad Yasevich { 9642be5c767SVlad Yasevich struct macvlan_dev *vlan = netdev_priv(dev); 96562dbe830SMichal Kubeček netdev_features_t lowerdev_features = vlan->lowerdev->features; 966797f87f8SFlorian Westphal netdev_features_t mask; 9672be5c767SVlad Yasevich 968797f87f8SFlorian Westphal features |= NETIF_F_ALL_FOR_ALL; 969797f87f8SFlorian Westphal features &= (vlan->set_features | ~MACVLAN_FEATURES); 970797f87f8SFlorian Westphal mask = features; 971797f87f8SFlorian Westphal 97262dbe830SMichal Kubeček lowerdev_features &= (features | ~NETIF_F_LRO); 97362dbe830SMichal Kubeček features = netdev_increment_features(lowerdev_features, features, mask); 9748b4703e9SVlad Yasevich features |= ALWAYS_ON_FEATURES; 9750d0162e7SFrancesco Ruggeri features &= ~NETIF_F_NETNS_LOCAL; 976797f87f8SFlorian Westphal 977797f87f8SFlorian Westphal return features; 9782be5c767SVlad Yasevich } 9792be5c767SVlad Yasevich 980688cea83Sdingtianhong #ifdef CONFIG_NET_POLL_CONTROLLER 981688cea83Sdingtianhong static void macvlan_dev_poll_controller(struct net_device *dev) 982688cea83Sdingtianhong { 983688cea83Sdingtianhong return; 984688cea83Sdingtianhong } 985688cea83Sdingtianhong 986688cea83Sdingtianhong static int macvlan_dev_netpoll_setup(struct net_device *dev, struct netpoll_info *npinfo) 987688cea83Sdingtianhong { 988688cea83Sdingtianhong struct macvlan_dev *vlan = netdev_priv(dev); 989688cea83Sdingtianhong struct net_device *real_dev = vlan->lowerdev; 990688cea83Sdingtianhong struct netpoll *netpoll; 991688cea83Sdingtianhong int err = 0; 992688cea83Sdingtianhong 993688cea83Sdingtianhong netpoll = kzalloc(sizeof(*netpoll), GFP_KERNEL); 994688cea83Sdingtianhong err = -ENOMEM; 995688cea83Sdingtianhong if (!netpoll) 996688cea83Sdingtianhong goto out; 997688cea83Sdingtianhong 998688cea83Sdingtianhong err = __netpoll_setup(netpoll, real_dev); 999688cea83Sdingtianhong if (err) { 1000688cea83Sdingtianhong kfree(netpoll); 1001688cea83Sdingtianhong goto out; 1002688cea83Sdingtianhong } 1003688cea83Sdingtianhong 1004688cea83Sdingtianhong vlan->netpoll = netpoll; 1005688cea83Sdingtianhong 1006688cea83Sdingtianhong out: 1007688cea83Sdingtianhong return err; 1008688cea83Sdingtianhong } 1009688cea83Sdingtianhong 1010688cea83Sdingtianhong static void macvlan_dev_netpoll_cleanup(struct net_device *dev) 1011688cea83Sdingtianhong { 1012688cea83Sdingtianhong struct macvlan_dev *vlan = netdev_priv(dev); 1013688cea83Sdingtianhong struct netpoll *netpoll = vlan->netpoll; 1014688cea83Sdingtianhong 1015688cea83Sdingtianhong if (!netpoll) 1016688cea83Sdingtianhong return; 1017688cea83Sdingtianhong 1018688cea83Sdingtianhong vlan->netpoll = NULL; 1019688cea83Sdingtianhong 1020688cea83Sdingtianhong __netpoll_free_async(netpoll); 1021688cea83Sdingtianhong } 1022688cea83Sdingtianhong #endif /* CONFIG_NET_POLL_CONTROLLER */ 1023688cea83Sdingtianhong 1024ef5fa6bcSNicolas Dichtel static int macvlan_dev_get_iflink(const struct net_device *dev) 1025ef5fa6bcSNicolas Dichtel { 1026ef5fa6bcSNicolas Dichtel struct macvlan_dev *vlan = netdev_priv(dev); 1027ef5fa6bcSNicolas Dichtel 1028ef5fa6bcSNicolas Dichtel return vlan->lowerdev->ifindex; 1029ef5fa6bcSNicolas Dichtel } 1030ef5fa6bcSNicolas Dichtel 1031b863ceb7SPatrick McHardy static const struct ethtool_ops macvlan_ethtool_ops = { 1032b863ceb7SPatrick McHardy .get_link = ethtool_op_get_link, 103385f95819SDavid Decotigny .get_link_ksettings = macvlan_ethtool_get_link_ksettings, 1034b863ceb7SPatrick McHardy .get_drvinfo = macvlan_ethtool_get_drvinfo, 1035b863ceb7SPatrick McHardy }; 1036b863ceb7SPatrick McHardy 103754a30c97SStephen Hemminger static const struct net_device_ops macvlan_netdev_ops = { 103854a30c97SStephen Hemminger .ndo_init = macvlan_init, 1039fccaf710SEric Dumazet .ndo_uninit = macvlan_uninit, 104054a30c97SStephen Hemminger .ndo_open = macvlan_open, 104154a30c97SStephen Hemminger .ndo_stop = macvlan_stop, 104200829823SStephen Hemminger .ndo_start_xmit = macvlan_start_xmit, 104354a30c97SStephen Hemminger .ndo_change_mtu = macvlan_change_mtu, 10442be5c767SVlad Yasevich .ndo_fix_features = macvlan_fix_features, 104554a30c97SStephen Hemminger .ndo_change_rx_flags = macvlan_change_rx_flags, 104654a30c97SStephen Hemminger .ndo_set_mac_address = macvlan_set_mac_address, 1047df8ef8f3SJohn Fastabend .ndo_set_rx_mode = macvlan_set_mac_lists, 1048bc66154eSEric Dumazet .ndo_get_stats64 = macvlan_dev_get_stats64, 104954a30c97SStephen Hemminger .ndo_validate_addr = eth_validate_addr, 10508d13e670SJohn Fastabend .ndo_vlan_rx_add_vid = macvlan_vlan_rx_add_vid, 10518d13e670SJohn Fastabend .ndo_vlan_rx_kill_vid = macvlan_vlan_rx_kill_vid, 1052df8ef8f3SJohn Fastabend .ndo_fdb_add = macvlan_fdb_add, 1053df8ef8f3SJohn Fastabend .ndo_fdb_del = macvlan_fdb_del, 1054df8ef8f3SJohn Fastabend .ndo_fdb_dump = ndo_dflt_fdb_dump, 1055c674ac30SVlad Yasevich .ndo_get_lock_subclass = macvlan_get_nest_level, 1056688cea83Sdingtianhong #ifdef CONFIG_NET_POLL_CONTROLLER 1057688cea83Sdingtianhong .ndo_poll_controller = macvlan_dev_poll_controller, 1058688cea83Sdingtianhong .ndo_netpoll_setup = macvlan_dev_netpoll_setup, 1059688cea83Sdingtianhong .ndo_netpoll_cleanup = macvlan_dev_netpoll_cleanup, 1060688cea83Sdingtianhong #endif 1061ef5fa6bcSNicolas Dichtel .ndo_get_iflink = macvlan_dev_get_iflink, 1062f56e67b5SToshiaki Makita .ndo_features_check = passthru_features_check, 106354a30c97SStephen Hemminger }; 106454a30c97SStephen Hemminger 10658a35747aSHerbert Xu void macvlan_common_setup(struct net_device *dev) 1066b863ceb7SPatrick McHardy { 1067b863ceb7SPatrick McHardy ether_setup(dev); 1068b863ceb7SPatrick McHardy 106902875878SEric Dumazet dev->priv_flags &= ~IFF_TX_SKB_SHARING; 107002875878SEric Dumazet netif_keep_dst(dev); 107187ab7f6fSVlad Yasevich dev->priv_flags |= IFF_UNICAST_FLT; 107254a30c97SStephen Hemminger dev->netdev_ops = &macvlan_netdev_ops; 1073b863ceb7SPatrick McHardy dev->destructor = free_netdev; 107471740129SLutz Jaenicke dev->header_ops = &macvlan_hard_header_ops; 1075b863ceb7SPatrick McHardy dev->ethtool_ops = &macvlan_ethtool_ops; 10768a35747aSHerbert Xu } 10778a35747aSHerbert Xu EXPORT_SYMBOL_GPL(macvlan_common_setup); 10788a35747aSHerbert Xu 10798a35747aSHerbert Xu static void macvlan_setup(struct net_device *dev) 10808a35747aSHerbert Xu { 10818a35747aSHerbert Xu macvlan_common_setup(dev); 10827009212bSZhang Shengju dev->priv_flags |= IFF_NO_QUEUE; 1083b863ceb7SPatrick McHardy } 1084b863ceb7SPatrick McHardy 1085b863ceb7SPatrick McHardy static int macvlan_port_create(struct net_device *dev) 1086b863ceb7SPatrick McHardy { 1087b863ceb7SPatrick McHardy struct macvlan_port *port; 1088b863ceb7SPatrick McHardy unsigned int i; 1089ab95bfe0SJiri Pirko int err; 1090b863ceb7SPatrick McHardy 1091b863ceb7SPatrick McHardy if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK) 1092b863ceb7SPatrick McHardy return -EINVAL; 1093b863ceb7SPatrick McHardy 1094d6b00fecSMahesh Bandewar if (netif_is_ipvlan_port(dev)) 1095d6b00fecSMahesh Bandewar return -EBUSY; 1096d6b00fecSMahesh Bandewar 1097b863ceb7SPatrick McHardy port = kzalloc(sizeof(*port), GFP_KERNEL); 1098b863ceb7SPatrick McHardy if (port == NULL) 1099b863ceb7SPatrick McHardy return -ENOMEM; 1100b863ceb7SPatrick McHardy 1101eb06acdcSSridhar Samudrala port->passthru = false; 1102b863ceb7SPatrick McHardy port->dev = dev; 1103b863ceb7SPatrick McHardy INIT_LIST_HEAD(&port->vlans); 1104b863ceb7SPatrick McHardy for (i = 0; i < MACVLAN_HASH_SIZE; i++) 1105b863ceb7SPatrick McHardy INIT_HLIST_HEAD(&port->vlan_hash[i]); 110679cf79abSMichael Braun for (i = 0; i < MACVLAN_HASH_SIZE; i++) 110779cf79abSMichael Braun INIT_HLIST_HEAD(&port->vlan_source_hash[i]); 1108ab95bfe0SJiri Pirko 1109412ca155SHerbert Xu skb_queue_head_init(&port->bc_queue); 1110412ca155SHerbert Xu INIT_WORK(&port->bc_work, macvlan_process_broadcast); 1111412ca155SHerbert Xu 1112a35e2c1bSJiri Pirko err = netdev_rx_handler_register(dev, macvlan_handle_frame, port); 1113a35e2c1bSJiri Pirko if (err) 1114ab95bfe0SJiri Pirko kfree(port); 1115d9351561SEric Dumazet else 1116a35e2c1bSJiri Pirko dev->priv_flags |= IFF_MACVLAN_PORT; 1117ab95bfe0SJiri Pirko return err; 1118b863ceb7SPatrick McHardy } 1119b863ceb7SPatrick McHardy 1120b863ceb7SPatrick McHardy static void macvlan_port_destroy(struct net_device *dev) 1121b863ceb7SPatrick McHardy { 1122e052f7e6SEric Dumazet struct macvlan_port *port = macvlan_port_get_rtnl(dev); 1123b863ceb7SPatrick McHardy 1124a35e2c1bSJiri Pirko dev->priv_flags &= ~IFF_MACVLAN_PORT; 1125ab95bfe0SJiri Pirko netdev_rx_handler_unregister(dev); 1126fe0ca732SEric Dumazet 1127fe0ca732SEric Dumazet /* After this point, no packet can schedule bc_work anymore, 1128fe0ca732SEric Dumazet * but we need to cancel it and purge left skbs if any. 1129fe0ca732SEric Dumazet */ 1130fe0ca732SEric Dumazet cancel_work_sync(&port->bc_work); 1131fe0ca732SEric Dumazet __skb_queue_purge(&port->bc_queue); 1132fe0ca732SEric Dumazet 11336e070aecSLai Jiangshan kfree_rcu(port, rcu); 1134b863ceb7SPatrick McHardy } 1135b863ceb7SPatrick McHardy 1136b863ceb7SPatrick McHardy static int macvlan_validate(struct nlattr *tb[], struct nlattr *data[]) 1137b863ceb7SPatrick McHardy { 1138b863ceb7SPatrick McHardy if (tb[IFLA_ADDRESS]) { 1139b863ceb7SPatrick McHardy if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) 1140b863ceb7SPatrick McHardy return -EINVAL; 1141b863ceb7SPatrick McHardy if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) 1142b863ceb7SPatrick McHardy return -EADDRNOTAVAIL; 1143b863ceb7SPatrick McHardy } 114427c0b1a8SArnd Bergmann 114515127478SMichael S. Tsirkin if (data && data[IFLA_MACVLAN_FLAGS] && 114615127478SMichael S. Tsirkin nla_get_u16(data[IFLA_MACVLAN_FLAGS]) & ~MACVLAN_FLAG_NOPROMISC) 114715127478SMichael S. Tsirkin return -EINVAL; 114815127478SMichael S. Tsirkin 114927c0b1a8SArnd Bergmann if (data && data[IFLA_MACVLAN_MODE]) { 115027c0b1a8SArnd Bergmann switch (nla_get_u32(data[IFLA_MACVLAN_MODE])) { 115127c0b1a8SArnd Bergmann case MACVLAN_MODE_PRIVATE: 115227c0b1a8SArnd Bergmann case MACVLAN_MODE_VEPA: 115327c0b1a8SArnd Bergmann case MACVLAN_MODE_BRIDGE: 1154eb06acdcSSridhar Samudrala case MACVLAN_MODE_PASSTHRU: 115579cf79abSMichael Braun case MACVLAN_MODE_SOURCE: 115627c0b1a8SArnd Bergmann break; 115727c0b1a8SArnd Bergmann default: 115827c0b1a8SArnd Bergmann return -EINVAL; 115927c0b1a8SArnd Bergmann } 116027c0b1a8SArnd Bergmann } 116179cf79abSMichael Braun 116279cf79abSMichael Braun if (data && data[IFLA_MACVLAN_MACADDR_MODE]) { 116379cf79abSMichael Braun switch (nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE])) { 116479cf79abSMichael Braun case MACVLAN_MACADDR_ADD: 116579cf79abSMichael Braun case MACVLAN_MACADDR_DEL: 116679cf79abSMichael Braun case MACVLAN_MACADDR_FLUSH: 116779cf79abSMichael Braun case MACVLAN_MACADDR_SET: 116879cf79abSMichael Braun break; 116979cf79abSMichael Braun default: 117079cf79abSMichael Braun return -EINVAL; 117179cf79abSMichael Braun } 117279cf79abSMichael Braun } 117379cf79abSMichael Braun 117479cf79abSMichael Braun if (data && data[IFLA_MACVLAN_MACADDR]) { 117579cf79abSMichael Braun if (nla_len(data[IFLA_MACVLAN_MACADDR]) != ETH_ALEN) 117679cf79abSMichael Braun return -EINVAL; 117779cf79abSMichael Braun 117879cf79abSMichael Braun if (!is_valid_ether_addr(nla_data(data[IFLA_MACVLAN_MACADDR]))) 117979cf79abSMichael Braun return -EADDRNOTAVAIL; 118079cf79abSMichael Braun } 118179cf79abSMichael Braun 118279cf79abSMichael Braun if (data && data[IFLA_MACVLAN_MACADDR_COUNT]) 118379cf79abSMichael Braun return -EINVAL; 118479cf79abSMichael Braun 118579cf79abSMichael Braun return 0; 118679cf79abSMichael Braun } 118779cf79abSMichael Braun 118879cf79abSMichael Braun /** 118979cf79abSMichael Braun * reconfigure list of remote source mac address 119079cf79abSMichael Braun * (only for macvlan devices in source mode) 119179cf79abSMichael Braun * Note regarding alignment: all netlink data is aligned to 4 Byte, which 119279cf79abSMichael Braun * suffices for both ether_addr_copy and ether_addr_equal_64bits usage. 119379cf79abSMichael Braun */ 119479cf79abSMichael Braun static int macvlan_changelink_sources(struct macvlan_dev *vlan, u32 mode, 119579cf79abSMichael Braun struct nlattr *data[]) 119679cf79abSMichael Braun { 119779cf79abSMichael Braun char *addr = NULL; 119879cf79abSMichael Braun int ret, rem, len; 119979cf79abSMichael Braun struct nlattr *nla, *head; 120079cf79abSMichael Braun struct macvlan_source_entry *entry; 120179cf79abSMichael Braun 120279cf79abSMichael Braun if (data[IFLA_MACVLAN_MACADDR]) 120379cf79abSMichael Braun addr = nla_data(data[IFLA_MACVLAN_MACADDR]); 120479cf79abSMichael Braun 120579cf79abSMichael Braun if (mode == MACVLAN_MACADDR_ADD) { 120679cf79abSMichael Braun if (!addr) 120779cf79abSMichael Braun return -EINVAL; 120879cf79abSMichael Braun 120979cf79abSMichael Braun return macvlan_hash_add_source(vlan, addr); 121079cf79abSMichael Braun 121179cf79abSMichael Braun } else if (mode == MACVLAN_MACADDR_DEL) { 121279cf79abSMichael Braun if (!addr) 121379cf79abSMichael Braun return -EINVAL; 121479cf79abSMichael Braun 121579cf79abSMichael Braun entry = macvlan_hash_lookup_source(vlan, addr); 121679cf79abSMichael Braun if (entry) { 121779cf79abSMichael Braun macvlan_hash_del_source(entry); 121879cf79abSMichael Braun vlan->macaddr_count--; 121979cf79abSMichael Braun } 122079cf79abSMichael Braun } else if (mode == MACVLAN_MACADDR_FLUSH) { 122179cf79abSMichael Braun macvlan_flush_sources(vlan->port, vlan); 122279cf79abSMichael Braun } else if (mode == MACVLAN_MACADDR_SET) { 122379cf79abSMichael Braun macvlan_flush_sources(vlan->port, vlan); 122479cf79abSMichael Braun 122579cf79abSMichael Braun if (addr) { 122679cf79abSMichael Braun ret = macvlan_hash_add_source(vlan, addr); 122779cf79abSMichael Braun if (ret) 122879cf79abSMichael Braun return ret; 122979cf79abSMichael Braun } 123079cf79abSMichael Braun 123179cf79abSMichael Braun if (!data || !data[IFLA_MACVLAN_MACADDR_DATA]) 123279cf79abSMichael Braun return 0; 123379cf79abSMichael Braun 123479cf79abSMichael Braun head = nla_data(data[IFLA_MACVLAN_MACADDR_DATA]); 123579cf79abSMichael Braun len = nla_len(data[IFLA_MACVLAN_MACADDR_DATA]); 123679cf79abSMichael Braun 123779cf79abSMichael Braun nla_for_each_attr(nla, head, len, rem) { 123879cf79abSMichael Braun if (nla_type(nla) != IFLA_MACVLAN_MACADDR || 123979cf79abSMichael Braun nla_len(nla) != ETH_ALEN) 124079cf79abSMichael Braun continue; 124179cf79abSMichael Braun 124279cf79abSMichael Braun addr = nla_data(nla); 124379cf79abSMichael Braun ret = macvlan_hash_add_source(vlan, addr); 124479cf79abSMichael Braun if (ret) 124579cf79abSMichael Braun return ret; 124679cf79abSMichael Braun } 124779cf79abSMichael Braun } else { 124879cf79abSMichael Braun return -EINVAL; 124979cf79abSMichael Braun } 125079cf79abSMichael Braun 1251b863ceb7SPatrick McHardy return 0; 1252b863ceb7SPatrick McHardy } 1253b863ceb7SPatrick McHardy 1254fc0663d6SArnd Bergmann int macvlan_common_newlink(struct net *src_net, struct net_device *dev, 12552f6a1b66SVlad Yasevich struct nlattr *tb[], struct nlattr *data[]) 1256b863ceb7SPatrick McHardy { 1257b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev); 1258b863ceb7SPatrick McHardy struct macvlan_port *port; 1259b863ceb7SPatrick McHardy struct net_device *lowerdev; 1260b863ceb7SPatrick McHardy int err; 126179cf79abSMichael Braun int macmode; 1262b863ceb7SPatrick McHardy 1263b863ceb7SPatrick McHardy if (!tb[IFLA_LINK]) 1264b863ceb7SPatrick McHardy return -EINVAL; 1265b863ceb7SPatrick McHardy 126681adee47SEric W. Biederman lowerdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 1267b863ceb7SPatrick McHardy if (lowerdev == NULL) 1268b863ceb7SPatrick McHardy return -ENODEV; 1269b863ceb7SPatrick McHardy 1270d70f2cf5SKevin Wallace /* When creating macvlans or macvtaps on top of other macvlans - use 1271b0832a29SEric Biederman * the real device as the lowerdev. 1272a6ca5f1dSPatrick McHardy */ 1273d70f2cf5SKevin Wallace if (netif_is_macvlan(lowerdev)) 1274d70f2cf5SKevin Wallace lowerdev = macvlan_dev_real_dev(lowerdev); 1275a6ca5f1dSPatrick McHardy 1276b863ceb7SPatrick McHardy if (!tb[IFLA_MTU]) 1277b863ceb7SPatrick McHardy dev->mtu = lowerdev->mtu; 1278b863ceb7SPatrick McHardy else if (dev->mtu > lowerdev->mtu) 1279b863ceb7SPatrick McHardy return -EINVAL; 1280b863ceb7SPatrick McHardy 1281b863ceb7SPatrick McHardy if (!tb[IFLA_ADDRESS]) 12827ce5d222SDanny Kukawka eth_hw_addr_random(dev); 1283b863ceb7SPatrick McHardy 1284a35e2c1bSJiri Pirko if (!macvlan_port_exists(lowerdev)) { 1285b863ceb7SPatrick McHardy err = macvlan_port_create(lowerdev); 1286b863ceb7SPatrick McHardy if (err < 0) 1287b863ceb7SPatrick McHardy return err; 1288b863ceb7SPatrick McHardy } 1289e052f7e6SEric Dumazet port = macvlan_port_get_rtnl(lowerdev); 1290b863ceb7SPatrick McHardy 1291eb06acdcSSridhar Samudrala /* Only 1 macvlan device can be created in passthru mode */ 1292eb06acdcSSridhar Samudrala if (port->passthru) 1293eb06acdcSSridhar Samudrala return -EINVAL; 1294eb06acdcSSridhar Samudrala 1295b863ceb7SPatrick McHardy vlan->lowerdev = lowerdev; 1296b863ceb7SPatrick McHardy vlan->dev = dev; 1297b863ceb7SPatrick McHardy vlan->port = port; 12982be5c767SVlad Yasevich vlan->set_features = MACVLAN_FEATURES; 1299c674ac30SVlad Yasevich vlan->nest_level = dev_get_nest_level(lowerdev, netif_is_macvlan) + 1; 1300b863ceb7SPatrick McHardy 130127c0b1a8SArnd Bergmann vlan->mode = MACVLAN_MODE_VEPA; 130227c0b1a8SArnd Bergmann if (data && data[IFLA_MACVLAN_MODE]) 130327c0b1a8SArnd Bergmann vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]); 130427c0b1a8SArnd Bergmann 1305df8ef8f3SJohn Fastabend if (data && data[IFLA_MACVLAN_FLAGS]) 1306df8ef8f3SJohn Fastabend vlan->flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]); 1307df8ef8f3SJohn Fastabend 1308eb06acdcSSridhar Samudrala if (vlan->mode == MACVLAN_MODE_PASSTHRU) { 13095e3c516bSDavid S. Miller if (port->count) 1310eb06acdcSSridhar Samudrala return -EINVAL; 1311eb06acdcSSridhar Samudrala port->passthru = true; 13128b98604eSBjørn Mork eth_hw_addr_inherit(dev, lowerdev); 1313eb06acdcSSridhar Samudrala } 1314eb06acdcSSridhar Samudrala 131579cf79abSMichael Braun if (data && data[IFLA_MACVLAN_MACADDR_MODE]) { 131679cf79abSMichael Braun if (vlan->mode != MACVLAN_MODE_SOURCE) 131779cf79abSMichael Braun return -EINVAL; 131879cf79abSMichael Braun macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]); 131979cf79abSMichael Braun err = macvlan_changelink_sources(vlan, macmode, data); 132079cf79abSMichael Braun if (err) 132179cf79abSMichael Braun return err; 132279cf79abSMichael Braun } 132379cf79abSMichael Braun 132447d4ab91SJohn Fastabend err = register_netdevice(dev); 132547d4ab91SJohn Fastabend if (err < 0) 132630837960SFrancesco Ruggeri return err; 132747d4ab91SJohn Fastabend 1328a6cc0cfaSJohn Fastabend dev->priv_flags |= IFF_MACVLAN; 13297cd43db7SJiri Pirko err = netdev_upper_dev_link(lowerdev, dev); 13307cd43db7SJiri Pirko if (err) 1331da37705cSCong Wang goto unregister_netdev; 1332b863ceb7SPatrick McHardy 1333233c7df0SJiri Pirko list_add_tail_rcu(&vlan->list, &port->vlans); 1334fc4a7489SPatrick Mullaney netif_stacked_transfer_operstate(lowerdev, dev); 1335de7d244dSNikolay Aleksandrov linkwatch_fire_event(dev); 1336f16d3d57SJiri Pirko 1337b863ceb7SPatrick McHardy return 0; 1338f16d3d57SJiri Pirko 1339da37705cSCong Wang unregister_netdev: 1340da37705cSCong Wang unregister_netdevice(dev); 1341f16d3d57SJiri Pirko 1342f16d3d57SJiri Pirko return err; 1343b863ceb7SPatrick McHardy } 1344fc0663d6SArnd Bergmann EXPORT_SYMBOL_GPL(macvlan_common_newlink); 1345b863ceb7SPatrick McHardy 1346fc0663d6SArnd Bergmann static int macvlan_newlink(struct net *src_net, struct net_device *dev, 1347fc0663d6SArnd Bergmann struct nlattr *tb[], struct nlattr *data[]) 1348fc0663d6SArnd Bergmann { 13492f6a1b66SVlad Yasevich return macvlan_common_newlink(src_net, dev, tb, data); 1350fc0663d6SArnd Bergmann } 1351fc0663d6SArnd Bergmann 1352fc0663d6SArnd Bergmann void macvlan_dellink(struct net_device *dev, struct list_head *head) 1353b863ceb7SPatrick McHardy { 1354b863ceb7SPatrick McHardy struct macvlan_dev *vlan = netdev_priv(dev); 1355b863ceb7SPatrick McHardy 135679cf79abSMichael Braun if (vlan->mode == MACVLAN_MODE_SOURCE) 135779cf79abSMichael Braun macvlan_flush_sources(vlan->port, vlan); 1358233c7df0SJiri Pirko list_del_rcu(&vlan->list); 135923289a37SEric Dumazet unregister_netdevice_queue(dev, head); 13607cd43db7SJiri Pirko netdev_upper_dev_unlink(vlan->lowerdev, dev); 1361b863ceb7SPatrick McHardy } 1362fc0663d6SArnd Bergmann EXPORT_SYMBOL_GPL(macvlan_dellink); 1363b863ceb7SPatrick McHardy 136427c0b1a8SArnd Bergmann static int macvlan_changelink(struct net_device *dev, 136527c0b1a8SArnd Bergmann struct nlattr *tb[], struct nlattr *data[]) 136627c0b1a8SArnd Bergmann { 136727c0b1a8SArnd Bergmann struct macvlan_dev *vlan = netdev_priv(dev); 1368266e8347SMichael S. Tsirkin enum macvlan_mode mode; 1369266e8347SMichael S. Tsirkin bool set_mode = false; 137079cf79abSMichael Braun enum macvlan_macaddr_mode macmode; 137179cf79abSMichael Braun int ret; 1372266e8347SMichael S. Tsirkin 1373266e8347SMichael S. Tsirkin /* Validate mode, but don't set yet: setting flags may fail. */ 1374266e8347SMichael S. Tsirkin if (data && data[IFLA_MACVLAN_MODE]) { 1375266e8347SMichael S. Tsirkin set_mode = true; 1376266e8347SMichael S. Tsirkin mode = nla_get_u32(data[IFLA_MACVLAN_MODE]); 1377266e8347SMichael S. Tsirkin /* Passthrough mode can't be set or cleared dynamically */ 1378266e8347SMichael S. Tsirkin if ((mode == MACVLAN_MODE_PASSTHRU) != 1379266e8347SMichael S. Tsirkin (vlan->mode == MACVLAN_MODE_PASSTHRU)) 1380266e8347SMichael S. Tsirkin return -EINVAL; 138179cf79abSMichael Braun if (vlan->mode == MACVLAN_MODE_SOURCE && 138279cf79abSMichael Braun vlan->mode != mode) 138379cf79abSMichael Braun macvlan_flush_sources(vlan->port, vlan); 1384266e8347SMichael S. Tsirkin } 138599ffc3e7SMichael S. Tsirkin 1386df8ef8f3SJohn Fastabend if (data && data[IFLA_MACVLAN_FLAGS]) { 1387df8ef8f3SJohn Fastabend __u16 flags = nla_get_u16(data[IFLA_MACVLAN_FLAGS]); 1388df8ef8f3SJohn Fastabend bool promisc = (flags ^ vlan->flags) & MACVLAN_FLAG_NOPROMISC; 138999ffc3e7SMichael S. Tsirkin if (vlan->port->passthru && promisc) { 139099ffc3e7SMichael S. Tsirkin int err; 1391df8ef8f3SJohn Fastabend 139299ffc3e7SMichael S. Tsirkin if (flags & MACVLAN_FLAG_NOPROMISC) 139399ffc3e7SMichael S. Tsirkin err = dev_set_promiscuity(vlan->lowerdev, -1); 139499ffc3e7SMichael S. Tsirkin else 139599ffc3e7SMichael S. Tsirkin err = dev_set_promiscuity(vlan->lowerdev, 1); 139699ffc3e7SMichael S. Tsirkin if (err < 0) 139799ffc3e7SMichael S. Tsirkin return err; 139899ffc3e7SMichael S. Tsirkin } 1399df8ef8f3SJohn Fastabend vlan->flags = flags; 1400df8ef8f3SJohn Fastabend } 1401266e8347SMichael S. Tsirkin if (set_mode) 1402266e8347SMichael S. Tsirkin vlan->mode = mode; 140379cf79abSMichael Braun if (data && data[IFLA_MACVLAN_MACADDR_MODE]) { 140479cf79abSMichael Braun if (vlan->mode != MACVLAN_MODE_SOURCE) 140579cf79abSMichael Braun return -EINVAL; 140679cf79abSMichael Braun macmode = nla_get_u32(data[IFLA_MACVLAN_MACADDR_MODE]); 140779cf79abSMichael Braun ret = macvlan_changelink_sources(vlan, macmode, data); 140879cf79abSMichael Braun if (ret) 140979cf79abSMichael Braun return ret; 141079cf79abSMichael Braun } 141127c0b1a8SArnd Bergmann return 0; 141227c0b1a8SArnd Bergmann } 141327c0b1a8SArnd Bergmann 141479cf79abSMichael Braun static size_t macvlan_get_size_mac(const struct macvlan_dev *vlan) 141579cf79abSMichael Braun { 141679cf79abSMichael Braun if (vlan->macaddr_count == 0) 141779cf79abSMichael Braun return 0; 141879cf79abSMichael Braun return nla_total_size(0) /* IFLA_MACVLAN_MACADDR_DATA */ 141979cf79abSMichael Braun + vlan->macaddr_count * nla_total_size(sizeof(u8) * ETH_ALEN); 142079cf79abSMichael Braun } 142179cf79abSMichael Braun 142227c0b1a8SArnd Bergmann static size_t macvlan_get_size(const struct net_device *dev) 142327c0b1a8SArnd Bergmann { 142479cf79abSMichael Braun struct macvlan_dev *vlan = netdev_priv(dev); 142579cf79abSMichael Braun 142601fe944fSEric Dumazet return (0 142701fe944fSEric Dumazet + nla_total_size(4) /* IFLA_MACVLAN_MODE */ 142801fe944fSEric Dumazet + nla_total_size(2) /* IFLA_MACVLAN_FLAGS */ 142979cf79abSMichael Braun + nla_total_size(4) /* IFLA_MACVLAN_MACADDR_COUNT */ 143079cf79abSMichael Braun + macvlan_get_size_mac(vlan) /* IFLA_MACVLAN_MACADDR */ 143101fe944fSEric Dumazet ); 143227c0b1a8SArnd Bergmann } 143327c0b1a8SArnd Bergmann 143479cf79abSMichael Braun static int macvlan_fill_info_macaddr(struct sk_buff *skb, 143579cf79abSMichael Braun const struct macvlan_dev *vlan, 143679cf79abSMichael Braun const int i) 143779cf79abSMichael Braun { 143879cf79abSMichael Braun struct hlist_head *h = &vlan->port->vlan_source_hash[i]; 143979cf79abSMichael Braun struct macvlan_source_entry *entry; 144079cf79abSMichael Braun 144179cf79abSMichael Braun hlist_for_each_entry_rcu(entry, h, hlist) { 144279cf79abSMichael Braun if (entry->vlan != vlan) 144379cf79abSMichael Braun continue; 144479cf79abSMichael Braun if (nla_put(skb, IFLA_MACVLAN_MACADDR, ETH_ALEN, entry->addr)) 144579cf79abSMichael Braun return 1; 144679cf79abSMichael Braun } 144779cf79abSMichael Braun return 0; 144879cf79abSMichael Braun } 144979cf79abSMichael Braun 145027c0b1a8SArnd Bergmann static int macvlan_fill_info(struct sk_buff *skb, 145127c0b1a8SArnd Bergmann const struct net_device *dev) 145227c0b1a8SArnd Bergmann { 145327c0b1a8SArnd Bergmann struct macvlan_dev *vlan = netdev_priv(dev); 145479cf79abSMichael Braun int i; 145579cf79abSMichael Braun struct nlattr *nest; 145627c0b1a8SArnd Bergmann 1457ead9a76cSDavid S. Miller if (nla_put_u32(skb, IFLA_MACVLAN_MODE, vlan->mode)) 1458ead9a76cSDavid S. Miller goto nla_put_failure; 1459df8ef8f3SJohn Fastabend if (nla_put_u16(skb, IFLA_MACVLAN_FLAGS, vlan->flags)) 1460df8ef8f3SJohn Fastabend goto nla_put_failure; 146179cf79abSMichael Braun if (nla_put_u32(skb, IFLA_MACVLAN_MACADDR_COUNT, vlan->macaddr_count)) 146279cf79abSMichael Braun goto nla_put_failure; 146379cf79abSMichael Braun if (vlan->macaddr_count > 0) { 146479cf79abSMichael Braun nest = nla_nest_start(skb, IFLA_MACVLAN_MACADDR_DATA); 146579cf79abSMichael Braun if (nest == NULL) 146679cf79abSMichael Braun goto nla_put_failure; 146779cf79abSMichael Braun 146879cf79abSMichael Braun for (i = 0; i < MACVLAN_HASH_SIZE; i++) { 146979cf79abSMichael Braun if (macvlan_fill_info_macaddr(skb, vlan, i)) 147079cf79abSMichael Braun goto nla_put_failure; 147179cf79abSMichael Braun } 147279cf79abSMichael Braun nla_nest_end(skb, nest); 147379cf79abSMichael Braun } 147427c0b1a8SArnd Bergmann return 0; 147527c0b1a8SArnd Bergmann 147627c0b1a8SArnd Bergmann nla_put_failure: 147727c0b1a8SArnd Bergmann return -EMSGSIZE; 147827c0b1a8SArnd Bergmann } 147927c0b1a8SArnd Bergmann 148027c0b1a8SArnd Bergmann static const struct nla_policy macvlan_policy[IFLA_MACVLAN_MAX + 1] = { 148127c0b1a8SArnd Bergmann [IFLA_MACVLAN_MODE] = { .type = NLA_U32 }, 1482df8ef8f3SJohn Fastabend [IFLA_MACVLAN_FLAGS] = { .type = NLA_U16 }, 148379cf79abSMichael Braun [IFLA_MACVLAN_MACADDR_MODE] = { .type = NLA_U32 }, 148479cf79abSMichael Braun [IFLA_MACVLAN_MACADDR] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, 148579cf79abSMichael Braun [IFLA_MACVLAN_MACADDR_DATA] = { .type = NLA_NESTED }, 148679cf79abSMichael Braun [IFLA_MACVLAN_MACADDR_COUNT] = { .type = NLA_U32 }, 148727c0b1a8SArnd Bergmann }; 148827c0b1a8SArnd Bergmann 1489fc0663d6SArnd Bergmann int macvlan_link_register(struct rtnl_link_ops *ops) 1490fc0663d6SArnd Bergmann { 1491fc0663d6SArnd Bergmann /* common fields */ 1492fc0663d6SArnd Bergmann ops->priv_size = sizeof(struct macvlan_dev); 1493fc0663d6SArnd Bergmann ops->validate = macvlan_validate; 1494fc0663d6SArnd Bergmann ops->maxtype = IFLA_MACVLAN_MAX; 1495fc0663d6SArnd Bergmann ops->policy = macvlan_policy; 1496fc0663d6SArnd Bergmann ops->changelink = macvlan_changelink; 1497fc0663d6SArnd Bergmann ops->get_size = macvlan_get_size; 1498fc0663d6SArnd Bergmann ops->fill_info = macvlan_fill_info; 1499fc0663d6SArnd Bergmann 1500fc0663d6SArnd Bergmann return rtnl_link_register(ops); 1501fc0663d6SArnd Bergmann }; 1502fc0663d6SArnd Bergmann EXPORT_SYMBOL_GPL(macvlan_link_register); 1503fc0663d6SArnd Bergmann 1504eaca400fSNicolas Dichtel static struct net *macvlan_get_link_net(const struct net_device *dev) 1505eaca400fSNicolas Dichtel { 1506eaca400fSNicolas Dichtel return dev_net(macvlan_dev_real_dev(dev)); 1507eaca400fSNicolas Dichtel } 1508eaca400fSNicolas Dichtel 1509fc0663d6SArnd Bergmann static struct rtnl_link_ops macvlan_link_ops = { 1510b863ceb7SPatrick McHardy .kind = "macvlan", 15118a35747aSHerbert Xu .setup = macvlan_setup, 1512b863ceb7SPatrick McHardy .newlink = macvlan_newlink, 1513b863ceb7SPatrick McHardy .dellink = macvlan_dellink, 1514eaca400fSNicolas Dichtel .get_link_net = macvlan_get_link_net, 1515b863ceb7SPatrick McHardy }; 1516b863ceb7SPatrick McHardy 1517b863ceb7SPatrick McHardy static int macvlan_device_event(struct notifier_block *unused, 1518b863ceb7SPatrick McHardy unsigned long event, void *ptr) 1519b863ceb7SPatrick McHardy { 1520351638e7SJiri Pirko struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1521b863ceb7SPatrick McHardy struct macvlan_dev *vlan, *next; 1522b863ceb7SPatrick McHardy struct macvlan_port *port; 1523226bd341SEric Dumazet LIST_HEAD(list_kill); 1524b863ceb7SPatrick McHardy 1525a35e2c1bSJiri Pirko if (!macvlan_port_exists(dev)) 1526b863ceb7SPatrick McHardy return NOTIFY_DONE; 1527b863ceb7SPatrick McHardy 1528e052f7e6SEric Dumazet port = macvlan_port_get_rtnl(dev); 1529a35e2c1bSJiri Pirko 1530b863ceb7SPatrick McHardy switch (event) { 1531de7d244dSNikolay Aleksandrov case NETDEV_UP: 1532b863ceb7SPatrick McHardy case NETDEV_CHANGE: 1533b863ceb7SPatrick McHardy list_for_each_entry(vlan, &port->vlans, list) 1534fc4a7489SPatrick Mullaney netif_stacked_transfer_operstate(vlan->lowerdev, 1535fc4a7489SPatrick Mullaney vlan->dev); 1536b863ceb7SPatrick McHardy break; 1537b863ceb7SPatrick McHardy case NETDEV_FEAT_CHANGE: 1538b863ceb7SPatrick McHardy list_for_each_entry(vlan, &port->vlans, list) { 15398c2acc53SPatrick McHardy vlan->dev->gso_max_size = dev->gso_max_size; 1540f6773c5eSEric Dumazet vlan->dev->gso_max_segs = dev->gso_max_segs; 1541797f87f8SFlorian Westphal netdev_update_features(vlan->dev); 1542b863ceb7SPatrick McHardy } 1543b863ceb7SPatrick McHardy break; 15443763e7efSdingtianhong case NETDEV_CHANGEMTU: 15453763e7efSdingtianhong list_for_each_entry(vlan, &port->vlans, list) { 15463763e7efSdingtianhong if (vlan->dev->mtu <= dev->mtu) 15473763e7efSdingtianhong continue; 15483763e7efSdingtianhong dev_set_mtu(vlan->dev, dev->mtu); 15493763e7efSdingtianhong } 15503763e7efSdingtianhong break; 1551e289fd28Sdingtianhong case NETDEV_CHANGEADDR: 1552e289fd28Sdingtianhong if (!port->passthru) 1553e289fd28Sdingtianhong return NOTIFY_DONE; 1554e289fd28Sdingtianhong 1555e289fd28Sdingtianhong vlan = list_first_entry_or_null(&port->vlans, 1556e289fd28Sdingtianhong struct macvlan_dev, 1557e289fd28Sdingtianhong list); 1558e289fd28Sdingtianhong 1559e289fd28Sdingtianhong if (macvlan_sync_address(vlan->dev, dev->dev_addr)) 1560e289fd28Sdingtianhong return NOTIFY_BAD; 1561e289fd28Sdingtianhong 1562e289fd28Sdingtianhong break; 1563b863ceb7SPatrick McHardy case NETDEV_UNREGISTER: 15643b27e105SDavid Lamparter /* twiddle thumbs on netns device moves */ 15653b27e105SDavid Lamparter if (dev->reg_state != NETREG_UNREGISTERING) 15663b27e105SDavid Lamparter break; 15673b27e105SDavid Lamparter 1568b863ceb7SPatrick McHardy list_for_each_entry_safe(vlan, next, &port->vlans, list) 1569226bd341SEric Dumazet vlan->dev->rtnl_link_ops->dellink(vlan->dev, &list_kill); 1570226bd341SEric Dumazet unregister_netdevice_many(&list_kill); 1571b863ceb7SPatrick McHardy break; 15721c01fe14SJiri Pirko case NETDEV_PRE_TYPE_CHANGE: 15731c01fe14SJiri Pirko /* Forbid underlaying device to change its type. */ 15741c01fe14SJiri Pirko return NOTIFY_BAD; 15754c991255SVlad Yasevich 15764c991255SVlad Yasevich case NETDEV_NOTIFY_PEERS: 15774c991255SVlad Yasevich case NETDEV_BONDING_FAILOVER: 15784c991255SVlad Yasevich case NETDEV_RESEND_IGMP: 15794c991255SVlad Yasevich /* Propagate to all vlans */ 15804c991255SVlad Yasevich list_for_each_entry(vlan, &port->vlans, list) 15814c991255SVlad Yasevich call_netdevice_notifiers(event, vlan->dev); 1582b863ceb7SPatrick McHardy } 1583b863ceb7SPatrick McHardy return NOTIFY_DONE; 1584b863ceb7SPatrick McHardy } 1585b863ceb7SPatrick McHardy 1586b863ceb7SPatrick McHardy static struct notifier_block macvlan_notifier_block __read_mostly = { 1587b863ceb7SPatrick McHardy .notifier_call = macvlan_device_event, 1588b863ceb7SPatrick McHardy }; 1589b863ceb7SPatrick McHardy 1590b863ceb7SPatrick McHardy static int __init macvlan_init_module(void) 1591b863ceb7SPatrick McHardy { 1592b863ceb7SPatrick McHardy int err; 1593b863ceb7SPatrick McHardy 1594b863ceb7SPatrick McHardy register_netdevice_notifier(&macvlan_notifier_block); 1595b863ceb7SPatrick McHardy 1596fc0663d6SArnd Bergmann err = macvlan_link_register(&macvlan_link_ops); 1597b863ceb7SPatrick McHardy if (err < 0) 1598b863ceb7SPatrick McHardy goto err1; 1599b863ceb7SPatrick McHardy return 0; 1600b863ceb7SPatrick McHardy err1: 1601b863ceb7SPatrick McHardy unregister_netdevice_notifier(&macvlan_notifier_block); 1602b863ceb7SPatrick McHardy return err; 1603b863ceb7SPatrick McHardy } 1604b863ceb7SPatrick McHardy 1605b863ceb7SPatrick McHardy static void __exit macvlan_cleanup_module(void) 1606b863ceb7SPatrick McHardy { 1607b863ceb7SPatrick McHardy rtnl_link_unregister(&macvlan_link_ops); 1608b863ceb7SPatrick McHardy unregister_netdevice_notifier(&macvlan_notifier_block); 1609b863ceb7SPatrick McHardy } 1610b863ceb7SPatrick McHardy 1611b863ceb7SPatrick McHardy module_init(macvlan_init_module); 1612b863ceb7SPatrick McHardy module_exit(macvlan_cleanup_module); 1613b863ceb7SPatrick McHardy 1614b863ceb7SPatrick McHardy MODULE_LICENSE("GPL"); 1615b863ceb7SPatrick McHardy MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>"); 1616b863ceb7SPatrick McHardy MODULE_DESCRIPTION("Driver for MAC address based VLANs"); 1617b863ceb7SPatrick McHardy MODULE_ALIAS_RTNL_LINK("macvlan"); 1618