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