projects/linux·blob master · refs

535 lines · 12.7 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Device handling code
4 * Linux ethernet bridge
5 *
6 * Authors:
7 * Lennert Buytenhek <[email protected]>
8 */
9
10#include <linux/kernel.h>
11#include <linux/netdevice.h>
12#include <linux/netpoll.h>
13#include <linux/etherdevice.h>
14#include <linux/ethtool.h>
15#include <linux/list.h>
16#include <linux/netfilter_bridge.h>
17
18#include <linux/uaccess.h>
19#include <net/netdev_lock.h>
20
21#include "br_private.h"
22
23#define COMMON_FEATURES (NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | \
24 NETIF_F_GSO_MASK | NETIF_F_HW_CSUM)
25
26const struct nf_br_ops __rcu *nf_br_ops __read_mostly;
27EXPORT_SYMBOL_GPL(nf_br_ops);
28
29/* net device transmit always called with BH disabled */
30netdev_tx_t br_dev_xmit(struct sk_buff *skb, struct net_device *dev)
31{
32 enum skb_drop_reason reason = pskb_may_pull_reason(skb, ETH_HLEN);
33 struct net_bridge_mcast_port *pmctx_null = NULL;
34 struct net_bridge *br = netdev_priv(dev);
35 struct net_bridge_mcast *brmctx = &br->multicast_ctx;
36 struct net_bridge_fdb_entry *dst;
37 struct net_bridge_mdb_entry *mdst;
38 const struct nf_br_ops *nf_ops;
39 u8 state = BR_STATE_FORWARDING;
40 struct net_bridge_vlan *vlan;
41 const unsigned char *dest;
42 u16 vid = 0;
43
44 if (unlikely(reason != SKB_NOT_DROPPED_YET)) {
45 kfree_skb_reason(skb, reason);
46 return NETDEV_TX_OK;
47 }
48
49 memset(skb->cb, 0, sizeof(struct br_input_skb_cb));
50 br_tc_skb_miss_set(skb, false);
51
52 rcu_read_lock();
53 nf_ops = rcu_dereference(nf_br_ops);
54 if (nf_ops && nf_ops->br_dev_xmit_hook(skb)) {
55 rcu_read_unlock();
56 return NETDEV_TX_OK;
57 }
58
59 dev_sw_netstats_tx_add(dev, 1, skb->len);
60
61 br_switchdev_frame_unmark(skb);
62 BR_INPUT_SKB_CB(skb)->brdev = dev;
63 BR_INPUT_SKB_CB(skb)->frag_max_size = 0;
64
65 skb_reset_mac_header(skb);
66 skb_pull(skb, ETH_HLEN);
67
68 if (!br_allowed_ingress(br, br_vlan_group_rcu(br), skb, &vid,
69 &state, &vlan))
70 goto out;
71
72 if (IS_ENABLED(CONFIG_INET) &&
73 (eth_hdr(skb)->h_proto == htons(ETH_P_ARP) ||
74 eth_hdr(skb)->h_proto == htons(ETH_P_RARP)) &&
75 br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED)) {
76 br_do_proxy_suppress_arp(skb, br, vid, NULL);
77 } else if (ipv6_mod_enabled() &&
78 skb->protocol == htons(ETH_P_IPV6) &&
79 br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED) &&
80 pskb_may_pull(skb, sizeof(struct ipv6hdr) +
81 sizeof(struct nd_msg)) &&
82 ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {
83 struct nd_msg *msg;
84
85 msg = br_is_nd_neigh_msg(skb);
86 if (msg)
87 br_do_suppress_nd(skb, br, vid, NULL, msg);
88 }
89
90 dest = eth_hdr(skb)->h_dest;
91 if (is_broadcast_ether_addr(dest)) {
92 br_flood(br, skb, BR_PKT_BROADCAST, false, true, vid);
93 } else if (is_multicast_ether_addr(dest)) {
94 if (unlikely(netpoll_tx_running(dev))) {
95 br_flood(br, skb, BR_PKT_MULTICAST, false, true, vid);
96 goto out;
97 }
98 if (br_multicast_rcv(&brmctx, &pmctx_null, vlan, skb, vid)) {
99 kfree_skb(skb);
100 goto out;
101 }
102
103 mdst = br_mdb_entry_skb_get(brmctx, skb, vid);
104 if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&
105 br_multicast_querier_exists(brmctx, eth_hdr(skb), mdst))
106 br_multicast_flood(mdst, skb, brmctx, false, true);
107 else
108 br_flood(br, skb, BR_PKT_MULTICAST, false, true, vid);
109 } else if ((dst = br_fdb_find_rcu(br, dest, vid)) != NULL) {
110 br_forward(READ_ONCE(dst->dst), skb, false, true);
111 } else {
112 br_flood(br, skb, BR_PKT_UNICAST, false, true, vid);
113 }
114out:
115 rcu_read_unlock();
116 return NETDEV_TX_OK;
117}
118
119static int br_dev_init(struct net_device *dev)
120{
121 struct net_bridge *br = netdev_priv(dev);
122 int err;
123
124 err = br_fdb_hash_init(br);
125 if (err)
126 return err;
127
128 err = br_mdb_hash_init(br);
129 if (err) {
130 br_fdb_hash_fini(br);
131 return err;
132 }
133
134 err = br_vlan_init(br);
135 if (err) {
136 br_mdb_hash_fini(br);
137 br_fdb_hash_fini(br);
138 return err;
139 }
140
141 err = br_multicast_init_stats(br);
142 if (err) {
143 br_vlan_flush(br);
144 br_mdb_hash_fini(br);
145 br_fdb_hash_fini(br);
146 return err;
147 }
148
149 netdev_lockdep_set_classes(dev);
150 return 0;
151}
152
153static void br_dev_uninit(struct net_device *dev)
154{
155 struct net_bridge *br = netdev_priv(dev);
156
157 br_multicast_dev_del(br);
158 br_multicast_uninit_stats(br);
159 br_vlan_flush(br);
160 br_mdb_hash_fini(br);
161 br_fdb_hash_fini(br);
162}
163
164static int br_dev_open(struct net_device *dev)
165{
166 struct net_bridge *br = netdev_priv(dev);
167
168 netdev_update_features(dev);
169 netif_start_queue(dev);
170 br_stp_enable_bridge(br);
171 br_multicast_open(br);
172
173 if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
174 br_multicast_join_snoopers(br);
175
176 return 0;
177}
178
179static void br_dev_set_multicast_list(struct net_device *dev)
180{
181}
182
183static void br_dev_change_rx_flags(struct net_device *dev, int change)
184{
185 if (change & IFF_PROMISC)
186 br_manage_promisc(netdev_priv(dev));
187}
188
189static int br_dev_stop(struct net_device *dev)
190{
191 struct net_bridge *br = netdev_priv(dev);
192
193 br_stp_disable_bridge(br);
194 br_multicast_stop(br);
195
196 if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
197 br_multicast_leave_snoopers(br);
198
199 netif_stop_queue(dev);
200
201 return 0;
202}
203
204static int br_change_mtu(struct net_device *dev, int new_mtu)
205{
206 struct net_bridge *br = netdev_priv(dev);
207
208 WRITE_ONCE(dev->mtu, new_mtu);
209
210 /* this flag will be cleared if the MTU was automatically adjusted */
211 br_opt_toggle(br, BROPT_MTU_SET_BY_USER, true);
212#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
213 /* remember the MTU in the rtable for PMTU */
214 dst_metric_set(&br->fake_rtable.dst, RTAX_MTU, new_mtu);
215#endif
216
217 return 0;
218}
219
220/* Allow setting mac address to any valid ethernet address. */
221static int br_set_mac_address(struct net_device *dev, void *p)
222{
223 struct net_bridge *br = netdev_priv(dev);
224 struct sockaddr *addr = p;
225
226 if (!is_valid_ether_addr(addr->sa_data))
227 return -EADDRNOTAVAIL;
228
229 /* dev_set_mac_addr() can be called by a master device on bridge's
230 * NETDEV_UNREGISTER, but since it's being destroyed do nothing
231 */
232 if (dev->reg_state != NETREG_REGISTERED)
233 return -EBUSY;
234
235 spin_lock_bh(&br->lock);
236 if (!ether_addr_equal(dev->dev_addr, addr->sa_data)) {
237 /* Mac address will be changed in br_stp_change_bridge_id(). */
238 br_stp_change_bridge_id(br, addr->sa_data);
239 }
240 spin_unlock_bh(&br->lock);
241
242 return 0;
243}
244
245static void br_getinfo(struct net_device *dev, struct ethtool_drvinfo *info)
246{
247 strscpy(info->driver, "bridge", sizeof(info->driver));
248 strscpy(info->version, BR_VERSION, sizeof(info->version));
249 strscpy(info->fw_version, "N/A", sizeof(info->fw_version));
250 strscpy(info->bus_info, "N/A", sizeof(info->bus_info));
251}
252
253static int br_get_link_ksettings(struct net_device *dev,
254 struct ethtool_link_ksettings *cmd)
255{
256 struct net_bridge *br = netdev_priv(dev);
257 struct net_bridge_port *p;
258
259 cmd->base.duplex = DUPLEX_UNKNOWN;
260 cmd->base.port = PORT_OTHER;
261 cmd->base.speed = SPEED_UNKNOWN;
262
263 list_for_each_entry(p, &br->port_list, list) {
264 struct ethtool_link_ksettings ecmd;
265 struct net_device *pdev = p->dev;
266
267 if (!netif_running(pdev) || !netif_oper_up(pdev))
268 continue;
269
270 if (__ethtool_get_link_ksettings(pdev, &ecmd))
271 continue;
272
273 if (ecmd.base.speed == (__u32)SPEED_UNKNOWN)
274 continue;
275
276 if (cmd->base.speed == (__u32)SPEED_UNKNOWN ||
277 cmd->base.speed < ecmd.base.speed)
278 cmd->base.speed = ecmd.base.speed;
279 }
280
281 return 0;
282}
283
284static netdev_features_t br_fix_features(struct net_device *dev,
285 netdev_features_t features)
286{
287 struct net_bridge *br = netdev_priv(dev);
288
289 return br_features_recompute(br, features);
290}
291
292#ifdef CONFIG_NET_POLL_CONTROLLER
293static void br_poll_controller(struct net_device *br_dev)
294{
295}
296
297static void br_netpoll_cleanup(struct net_device *dev)
298{
299 struct net_bridge *br = netdev_priv(dev);
300 struct net_bridge_port *p;
301
302 list_for_each_entry(p, &br->port_list, list)
303 br_netpoll_disable(p);
304}
305
306static int __br_netpoll_enable(struct net_bridge_port *p)
307{
308 struct netpoll *np;
309 int err;
310
311 np = kzalloc_obj(*p->np);
312 if (!np)
313 return -ENOMEM;
314
315 err = __netpoll_setup(np, p->dev);
316 if (err) {
317 kfree(np);
318 return err;
319 }
320
321 p->np = np;
322 return err;
323}
324
325int br_netpoll_enable(struct net_bridge_port *p)
326{
327 if (!p->br->dev->npinfo)
328 return 0;
329
330 return __br_netpoll_enable(p);
331}
332
333static int br_netpoll_setup(struct net_device *dev)
334{
335 struct net_bridge *br = netdev_priv(dev);
336 struct net_bridge_port *p;
337 int err = 0;
338
339 list_for_each_entry(p, &br->port_list, list) {
340 if (!p->dev)
341 continue;
342 err = __br_netpoll_enable(p);
343 if (err)
344 goto fail;
345 }
346
347out:
348 return err;
349
350fail:
351 br_netpoll_cleanup(dev);
352 goto out;
353}
354
355void br_netpoll_disable(struct net_bridge_port *p)
356{
357 struct netpoll *np = p->np;
358
359 if (!np)
360 return;
361
362 p->np = NULL;
363
364 __netpoll_free(np);
365}
366
367#endif
368
369static int br_add_slave(struct net_device *dev, struct net_device *slave_dev,
370 struct netlink_ext_ack *extack)
371
372{
373 struct net_bridge *br = netdev_priv(dev);
374
375 return br_add_if(br, slave_dev, extack);
376}
377
378static int br_del_slave(struct net_device *dev, struct net_device *slave_dev)
379{
380 struct net_bridge *br = netdev_priv(dev);
381
382 return br_del_if(br, slave_dev);
383}
384
385static int br_fill_forward_path(struct net_device_path_ctx *ctx,
386 struct net_device_path *path)
387{
388 struct net_bridge_fdb_entry *f;
389 struct net_bridge_port *dst;
390 struct net_bridge *br;
391
392 if (netif_is_bridge_port(ctx->dev))
393 return -1;
394
395 br = netdev_priv(ctx->dev);
396
397 br_vlan_fill_forward_path_pvid(br, ctx, path);
398
399 f = br_fdb_find_rcu(br, ctx->daddr, path->bridge.vlan_id);
400 if (!f)
401 return -1;
402
403 dst = READ_ONCE(f->dst);
404 if (!dst)
405 return -1;
406
407 if (br_vlan_fill_forward_path_mode(br, dst, path))
408 return -1;
409
410 path->type = DEV_PATH_BRIDGE;
411 path->dev = dst->br->dev;
412 ctx->dev = dst->dev;
413
414 switch (path->bridge.vlan_mode) {
415 case DEV_PATH_BR_VLAN_TAG:
416 if (ctx->num_vlans >= ARRAY_SIZE(ctx->vlan))
417 return -ENOSPC;
418 ctx->vlan[ctx->num_vlans].id = path->bridge.vlan_id;
419 ctx->vlan[ctx->num_vlans].proto = path->bridge.vlan_proto;
420 ctx->num_vlans++;
421 break;
422 case DEV_PATH_BR_VLAN_UNTAG_HW:
423 case DEV_PATH_BR_VLAN_UNTAG:
424 ctx->num_vlans--;
425 break;
426 case DEV_PATH_BR_VLAN_KEEP:
427 break;
428 }
429
430 return 0;
431}
432
433static const struct ethtool_ops br_ethtool_ops = {
434 .get_drvinfo = br_getinfo,
435 .get_link = ethtool_op_get_link,
436 .get_link_ksettings = br_get_link_ksettings,
437};
438
439static const struct net_device_ops br_netdev_ops = {
440 .ndo_open = br_dev_open,
441 .ndo_stop = br_dev_stop,
442 .ndo_init = br_dev_init,
443 .ndo_uninit = br_dev_uninit,
444 .ndo_start_xmit = br_dev_xmit,
445 .ndo_get_stats64 = dev_get_tstats64,
446 .ndo_set_mac_address = br_set_mac_address,
447 .ndo_set_rx_mode = br_dev_set_multicast_list,
448 .ndo_change_rx_flags = br_dev_change_rx_flags,
449 .ndo_change_mtu = br_change_mtu,
450 .ndo_siocdevprivate = br_dev_siocdevprivate,
451#ifdef CONFIG_NET_POLL_CONTROLLER
452 .ndo_netpoll_setup = br_netpoll_setup,
453 .ndo_netpoll_cleanup = br_netpoll_cleanup,
454 .ndo_poll_controller = br_poll_controller,
455#endif
456 .ndo_add_slave = br_add_slave,
457 .ndo_del_slave = br_del_slave,
458 .ndo_fix_features = br_fix_features,
459 .ndo_fdb_add = br_fdb_add,
460 .ndo_fdb_del = br_fdb_delete,
461 .ndo_fdb_del_bulk = br_fdb_delete_bulk,
462 .ndo_fdb_dump = br_fdb_dump,
463 .ndo_fdb_get = br_fdb_get,
464 .ndo_mdb_add = br_mdb_add,
465 .ndo_mdb_del = br_mdb_del,
466 .ndo_mdb_del_bulk = br_mdb_del_bulk,
467 .ndo_mdb_dump = br_mdb_dump,
468 .ndo_mdb_get = br_mdb_get,
469 .ndo_bridge_getlink = br_getlink,
470 .ndo_bridge_setlink = br_setlink,
471 .ndo_bridge_dellink = br_dellink,
472 .ndo_features_check = passthru_features_check,
473 .ndo_fill_forward_path = br_fill_forward_path,
474};
475
476static const struct device_type br_type = {
477 .name = "bridge",
478};
479
480void br_dev_setup(struct net_device *dev)
481{
482 struct net_bridge *br = netdev_priv(dev);
483
484 eth_hw_addr_random(dev);
485 ether_setup(dev);
486
487 dev->netdev_ops = &br_netdev_ops;
488 dev->needs_free_netdev = true;
489 dev->ethtool_ops = &br_ethtool_ops;
490 SET_NETDEV_DEVTYPE(dev, &br_type);
491 dev->priv_flags = IFF_EBRIDGE | IFF_NO_QUEUE;
492 dev->lltx = true;
493 dev->netns_immutable = true;
494
495 dev->features = COMMON_FEATURES | NETIF_F_HW_VLAN_CTAG_TX |
496 NETIF_F_HW_VLAN_STAG_TX;
497 dev->hw_features = COMMON_FEATURES | NETIF_F_HW_VLAN_CTAG_TX |
498 NETIF_F_HW_VLAN_STAG_TX;
499 dev->vlan_features = COMMON_FEATURES;
500 dev->pcpu_stat_type = NETDEV_PCPU_STAT_TSTATS;
501
502 br->dev = dev;
503 spin_lock_init(&br->lock);
504 INIT_LIST_HEAD(&br->port_list);
505 INIT_HLIST_HEAD(&br->fdb_list);
506#if IS_ENABLED(CONFIG_BRIDGE_MRP)
507 INIT_HLIST_HEAD(&br->mrp_list);
508#endif
509#if IS_ENABLED(CONFIG_BRIDGE_CFM)
510 INIT_HLIST_HEAD(&br->mep_list);
511#endif
512 spin_lock_init(&br->hash_lock);
513
514 br->bridge_id.prio[0] = 0x80;
515 br->bridge_id.prio[1] = 0x00;
516
517 ether_addr_copy(br->group_addr, eth_stp_addr);
518
519 br->stp_enabled = BR_NO_STP;
520 br->stp_mode = BR_STP_MODE_AUTO;
521 br->group_fwd_mask = BR_GROUPFWD_DEFAULT;
522 br->group_fwd_mask_required = BR_GROUPFWD_DEFAULT;
523
524 br->designated_root = br->bridge_id;
525 br->bridge_max_age = br->max_age = 20 * HZ;
526 br->bridge_hello_time = br->hello_time = 2 * HZ;
527 br->bridge_forward_delay = br->forward_delay = 15 * HZ;
528 br->bridge_ageing_time = br->ageing_time = BR_DEFAULT_AGEING_TIME;
529 dev->max_mtu = ETH_MAX_MTU;
530
531 br_netfilter_rtable_init(br);
532 br_stp_timer_init(br);
533 br_multicast_init(br);
534 INIT_DELAYED_WORK(&br->gc_work, br_fdb_cleanup);
535}