1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * Linux ethernet bridge
7 * Lennert Buytenhek <buytenh@gnu.org>
10 #include <linux/kernel.h>
11 #include <linux/netdevice.h>
12 #include <linux/etherdevice.h>
13 #include <linux/netpoll.h>
14 #include <linux/ethtool.h>
15 #include <linux/if_arp.h>
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/rtnetlink.h>
19 #include <linux/if_ether.h>
20 #include <linux/slab.h>
23 #include <linux/if_vlan.h>
24 #include <net/switchdev.h>
25 #include <net/net_namespace.h>
27 #include "br_private.h"
30 * Determine initial path cost based on speed.
31 * using recommendations from 802.1d standard
33 * Since driver might sleep need to not be holding any locks.
35 static int port_cost(struct net_device
*dev
)
37 struct ethtool_link_ksettings ecmd
;
39 if (!__ethtool_get_link_ksettings(dev
, &ecmd
)) {
40 switch (ecmd
.base
.speed
) {
52 /* Old silly heuristics based on name */
53 if (!strncmp(dev
->name
, "lec", 3))
56 if (!strncmp(dev
->name
, "plip", 4))
59 return 100; /* assume old 10Mbps */
63 /* Check for port carrier transitions. */
64 void br_port_carrier_check(struct net_bridge_port
*p
, bool *notified
)
66 struct net_device
*dev
= p
->dev
;
67 struct net_bridge
*br
= p
->br
;
69 if (!(p
->flags
& BR_ADMIN_COST
) &&
70 netif_running(dev
) && netif_oper_up(dev
))
71 p
->path_cost
= port_cost(dev
);
74 if (!netif_running(br
->dev
))
77 spin_lock_bh(&br
->lock
);
78 if (netif_running(dev
) && netif_oper_up(dev
)) {
79 if (p
->state
== BR_STATE_DISABLED
) {
80 br_stp_enable_port(p
);
84 if (p
->state
!= BR_STATE_DISABLED
) {
85 br_stp_disable_port(p
);
89 spin_unlock_bh(&br
->lock
);
92 static void br_port_set_promisc(struct net_bridge_port
*p
)
96 if (br_promisc_port(p
))
99 err
= dev_set_promiscuity(p
->dev
, 1);
103 br_fdb_unsync_static(p
->br
, p
);
104 p
->flags
|= BR_PROMISC
;
107 static void br_port_clear_promisc(struct net_bridge_port
*p
)
111 /* Check if the port is already non-promisc or if it doesn't
112 * support UNICAST filtering. Without unicast filtering support
113 * we'll end up re-enabling promisc mode anyway, so just check for
116 if (!br_promisc_port(p
) || !(p
->dev
->priv_flags
& IFF_UNICAST_FLT
))
119 /* Since we'll be clearing the promisc mode, program the port
120 * first so that we don't have interruption in traffic.
122 err
= br_fdb_sync_static(p
->br
, p
);
126 dev_set_promiscuity(p
->dev
, -1);
127 p
->flags
&= ~BR_PROMISC
;
130 /* When a port is added or removed or when certain port flags
131 * change, this function is called to automatically manage
132 * promiscuity setting of all the bridge ports. We are always called
133 * under RTNL so can skip using rcu primitives.
135 void br_manage_promisc(struct net_bridge
*br
)
137 struct net_bridge_port
*p
;
138 bool set_all
= false;
140 /* If vlan filtering is disabled or bridge interface is placed
141 * into promiscuous mode, place all ports in promiscuous mode.
143 if ((br
->dev
->flags
& IFF_PROMISC
) || !br_vlan_enabled(br
->dev
))
146 list_for_each_entry(p
, &br
->port_list
, list
) {
148 br_port_set_promisc(p
);
150 /* If the number of auto-ports is <= 1, then all other
151 * ports will have their output configuration
152 * statically specified through fdbs. Since ingress
153 * on the auto-port becomes forwarding/egress to other
154 * ports and egress configuration is statically known,
155 * we can say that ingress configuration of the
156 * auto-port is also statically known.
157 * This lets us disable promiscuous mode and write
160 if (br
->auto_cnt
== 0 ||
161 (br
->auto_cnt
== 1 && br_auto_port(p
)))
162 br_port_clear_promisc(p
);
164 br_port_set_promisc(p
);
169 int nbp_backup_change(struct net_bridge_port
*p
,
170 struct net_device
*backup_dev
)
172 struct net_bridge_port
*old_backup
= rtnl_dereference(p
->backup_port
);
173 struct net_bridge_port
*backup_p
= NULL
;
178 if (!netif_is_bridge_port(backup_dev
))
181 backup_p
= br_port_get_rtnl(backup_dev
);
182 if (backup_p
->br
!= p
->br
)
189 if (old_backup
== backup_p
)
192 /* if the backup link is already set, clear it */
194 old_backup
->backup_redirected_cnt
--;
197 backup_p
->backup_redirected_cnt
++;
198 rcu_assign_pointer(p
->backup_port
, backup_p
);
203 static void nbp_backup_clear(struct net_bridge_port
*p
)
205 nbp_backup_change(p
, NULL
);
206 if (p
->backup_redirected_cnt
) {
207 struct net_bridge_port
*cur_p
;
209 list_for_each_entry(cur_p
, &p
->br
->port_list
, list
) {
210 struct net_bridge_port
*backup_p
;
212 backup_p
= rtnl_dereference(cur_p
->backup_port
);
214 nbp_backup_change(cur_p
, NULL
);
218 WARN_ON(rcu_access_pointer(p
->backup_port
) || p
->backup_redirected_cnt
);
221 static void nbp_update_port_count(struct net_bridge
*br
)
223 struct net_bridge_port
*p
;
226 list_for_each_entry(p
, &br
->port_list
, list
) {
230 if (br
->auto_cnt
!= cnt
) {
232 br_manage_promisc(br
);
236 static void nbp_delete_promisc(struct net_bridge_port
*p
)
238 /* If port is currently promiscuous, unset promiscuity.
239 * Otherwise, it is a static port so remove all addresses
242 dev_set_allmulti(p
->dev
, -1);
243 if (br_promisc_port(p
))
244 dev_set_promiscuity(p
->dev
, -1);
246 br_fdb_unsync_static(p
->br
, p
);
249 static void release_nbp(struct kobject
*kobj
)
251 struct net_bridge_port
*p
252 = container_of(kobj
, struct net_bridge_port
, kobj
);
256 static void brport_get_ownership(struct kobject
*kobj
, kuid_t
*uid
, kgid_t
*gid
)
258 struct net_bridge_port
*p
= kobj_to_brport(kobj
);
260 net_ns_get_ownership(dev_net(p
->dev
), uid
, gid
);
263 static struct kobj_type brport_ktype
= {
265 .sysfs_ops
= &brport_sysfs_ops
,
267 .release
= release_nbp
,
268 .get_ownership
= brport_get_ownership
,
271 static void destroy_nbp(struct net_bridge_port
*p
)
273 struct net_device
*dev
= p
->dev
;
279 kobject_put(&p
->kobj
);
282 static void destroy_nbp_rcu(struct rcu_head
*head
)
284 struct net_bridge_port
*p
=
285 container_of(head
, struct net_bridge_port
, rcu
);
289 static unsigned get_max_headroom(struct net_bridge
*br
)
291 unsigned max_headroom
= 0;
292 struct net_bridge_port
*p
;
294 list_for_each_entry(p
, &br
->port_list
, list
) {
295 unsigned dev_headroom
= netdev_get_fwd_headroom(p
->dev
);
297 if (dev_headroom
> max_headroom
)
298 max_headroom
= dev_headroom
;
304 static void update_headroom(struct net_bridge
*br
, int new_hr
)
306 struct net_bridge_port
*p
;
308 list_for_each_entry(p
, &br
->port_list
, list
)
309 netdev_set_rx_headroom(p
->dev
, new_hr
);
311 br
->dev
->needed_headroom
= new_hr
;
314 /* Delete port(interface) from bridge is done in two steps.
315 * via RCU. First step, marks device as down. That deletes
316 * all the timers and stops new packets from flowing through.
318 * Final cleanup doesn't occur until after all CPU's finished
319 * processing packets.
321 * Protected from multiple admin operations by RTNL mutex
323 static void del_nbp(struct net_bridge_port
*p
)
325 struct net_bridge
*br
= p
->br
;
326 struct net_device
*dev
= p
->dev
;
328 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
330 nbp_delete_promisc(p
);
332 spin_lock_bh(&br
->lock
);
333 br_stp_disable_port(p
);
334 spin_unlock_bh(&br
->lock
);
336 br_mrp_port_del(br
, p
);
338 br_ifinfo_notify(RTM_DELLINK
, NULL
, p
);
340 list_del_rcu(&p
->list
);
341 if (netdev_get_fwd_headroom(dev
) == br
->dev
->needed_headroom
)
342 update_headroom(br
, get_max_headroom(br
));
343 netdev_reset_rx_headroom(dev
);
346 br_fdb_delete_by_port(br
, p
, 0, 1);
347 switchdev_deferred_process();
350 nbp_update_port_count(br
);
352 netdev_upper_dev_unlink(dev
, br
->dev
);
354 dev
->priv_flags
&= ~IFF_BRIDGE_PORT
;
356 netdev_rx_handler_unregister(dev
);
358 br_multicast_del_port(p
);
360 kobject_uevent(&p
->kobj
, KOBJ_REMOVE
);
361 kobject_del(&p
->kobj
);
363 br_netpoll_disable(p
);
365 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
368 /* Delete bridge device */
369 void br_dev_delete(struct net_device
*dev
, struct list_head
*head
)
371 struct net_bridge
*br
= netdev_priv(dev
);
372 struct net_bridge_port
*p
, *n
;
374 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
378 br_recalculate_neigh_suppress_enabled(br
);
380 br_fdb_delete_by_port(br
, NULL
, 0, 1);
382 cancel_delayed_work_sync(&br
->gc_work
);
384 br_sysfs_delbr(br
->dev
);
385 unregister_netdevice_queue(br
->dev
, head
);
388 /* find an available port number */
389 static int find_portno(struct net_bridge
*br
)
392 struct net_bridge_port
*p
;
393 unsigned long *inuse
;
395 inuse
= bitmap_zalloc(BR_MAX_PORTS
, GFP_KERNEL
);
399 set_bit(0, inuse
); /* zero is reserved */
400 list_for_each_entry(p
, &br
->port_list
, list
) {
401 set_bit(p
->port_no
, inuse
);
403 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
406 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
409 /* called with RTNL but without bridge lock */
410 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
411 struct net_device
*dev
)
413 struct net_bridge_port
*p
;
416 index
= find_portno(br
);
418 return ERR_PTR(index
);
420 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
422 return ERR_PTR(-ENOMEM
);
427 p
->path_cost
= port_cost(dev
);
428 p
->priority
= 0x8000 >> BR_PORT_BITS
;
430 p
->flags
= BR_LEARNING
| BR_FLOOD
| BR_MCAST_FLOOD
| BR_BCAST_FLOOD
;
432 br_set_state(p
, BR_STATE_DISABLED
);
433 br_stp_port_timer_init(p
);
434 err
= br_multicast_add_port(p
);
444 int br_add_bridge(struct net
*net
, const char *name
)
446 struct net_device
*dev
;
449 dev
= alloc_netdev(sizeof(struct net_bridge
), name
, NET_NAME_UNKNOWN
,
455 dev_net_set(dev
, net
);
456 dev
->rtnl_link_ops
= &br_link_ops
;
458 res
= register_netdev(dev
);
464 int br_del_bridge(struct net
*net
, const char *name
)
466 struct net_device
*dev
;
470 dev
= __dev_get_by_name(net
, name
);
472 ret
= -ENXIO
; /* Could not find device */
474 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
475 /* Attempt to delete non bridge device! */
479 else if (dev
->flags
& IFF_UP
) {
480 /* Not shutdown yet. */
485 br_dev_delete(dev
, NULL
);
491 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
492 static int br_mtu_min(const struct net_bridge
*br
)
494 const struct net_bridge_port
*p
;
497 list_for_each_entry(p
, &br
->port_list
, list
)
498 if (!ret_mtu
|| ret_mtu
> p
->dev
->mtu
)
499 ret_mtu
= p
->dev
->mtu
;
501 return ret_mtu
? ret_mtu
: ETH_DATA_LEN
;
504 void br_mtu_auto_adjust(struct net_bridge
*br
)
508 /* if the bridge MTU was manually configured don't mess with it */
509 if (br_opt_get(br
, BROPT_MTU_SET_BY_USER
))
512 /* change to the minimum MTU and clear the flag which was set by
513 * the bridge ndo_change_mtu callback
515 dev_set_mtu(br
->dev
, br_mtu_min(br
));
516 br_opt_toggle(br
, BROPT_MTU_SET_BY_USER
, false);
519 static void br_set_gso_limits(struct net_bridge
*br
)
521 unsigned int gso_max_size
= GSO_MAX_SIZE
;
522 u16 gso_max_segs
= GSO_MAX_SEGS
;
523 const struct net_bridge_port
*p
;
525 list_for_each_entry(p
, &br
->port_list
, list
) {
526 gso_max_size
= min(gso_max_size
, p
->dev
->gso_max_size
);
527 gso_max_segs
= min(gso_max_segs
, p
->dev
->gso_max_segs
);
529 br
->dev
->gso_max_size
= gso_max_size
;
530 br
->dev
->gso_max_segs
= gso_max_segs
;
534 * Recomputes features using slave's features
536 netdev_features_t
br_features_recompute(struct net_bridge
*br
,
537 netdev_features_t features
)
539 struct net_bridge_port
*p
;
540 netdev_features_t mask
;
542 if (list_empty(&br
->port_list
))
546 features
&= ~NETIF_F_ONE_FOR_ALL
;
548 list_for_each_entry(p
, &br
->port_list
, list
) {
549 features
= netdev_increment_features(features
,
550 p
->dev
->features
, mask
);
552 features
= netdev_add_tso_features(features
, mask
);
557 /* called with RTNL */
558 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
,
559 struct netlink_ext_ack
*extack
)
561 struct net_bridge_port
*p
;
563 unsigned br_hr
, dev_hr
;
566 /* Don't allow bridging non-ethernet like devices. */
567 if ((dev
->flags
& IFF_LOOPBACK
) ||
568 dev
->type
!= ARPHRD_ETHER
|| dev
->addr_len
!= ETH_ALEN
||
569 !is_valid_ether_addr(dev
->dev_addr
))
572 /* Also don't allow bridging of net devices that are DSA masters, since
573 * the bridge layer rx_handler prevents the DSA fake ethertype handler
574 * to be invoked, so we don't get the chance to strip off and parse the
575 * DSA switch tag protocol header (the bridge layer just returns
576 * RX_HANDLER_CONSUMED, stopping RX processing for these frames).
577 * The only case where that would not be an issue is when bridging can
578 * already be offloaded, such as when the DSA master is itself a DSA
579 * or plain switchdev port, and is bridged only with other ports from
580 * the same hardware device.
582 if (netdev_uses_dsa(dev
)) {
583 list_for_each_entry(p
, &br
->port_list
, list
) {
584 if (!netdev_port_same_parent_id(dev
, p
->dev
)) {
585 NL_SET_ERR_MSG(extack
,
586 "Cannot do software bridging with a DSA master");
592 /* No bridging of bridges */
593 if (dev
->netdev_ops
->ndo_start_xmit
== br_dev_xmit
) {
594 NL_SET_ERR_MSG(extack
,
595 "Can not enslave a bridge to a bridge");
599 /* Device has master upper dev */
600 if (netdev_master_upper_dev_get(dev
))
603 /* No bridging devices that dislike that (e.g. wireless) */
604 if (dev
->priv_flags
& IFF_DONT_BRIDGE
) {
605 NL_SET_ERR_MSG(extack
,
606 "Device does not allow enslaving to a bridge");
610 p
= new_nbp(br
, dev
);
614 call_netdevice_notifiers(NETDEV_JOIN
, dev
);
616 err
= dev_set_allmulti(dev
, 1);
618 kfree(p
); /* kobject not yet init'd, manually free */
622 err
= kobject_init_and_add(&p
->kobj
, &brport_ktype
, &(dev
->dev
.kobj
),
623 SYSFS_BRIDGE_PORT_ATTR
);
627 err
= br_sysfs_addif(p
);
631 err
= br_netpoll_enable(p
);
635 err
= netdev_rx_handler_register(dev
, br_get_rx_handler(dev
), p
);
639 dev
->priv_flags
|= IFF_BRIDGE_PORT
;
641 err
= netdev_master_upper_dev_link(dev
, br
->dev
, NULL
, NULL
, extack
);
645 err
= nbp_switchdev_mark_set(p
);
649 dev_disable_lro(dev
);
651 list_add_rcu(&p
->list
, &br
->port_list
);
653 nbp_update_port_count(br
);
655 netdev_update_features(br
->dev
);
657 br_hr
= br
->dev
->needed_headroom
;
658 dev_hr
= netdev_get_fwd_headroom(dev
);
660 update_headroom(br
, dev_hr
);
662 netdev_set_rx_headroom(dev
, br_hr
);
664 if (br_fdb_insert(br
, p
, dev
->dev_addr
, 0))
665 netdev_err(dev
, "failed insert local address bridge forwarding table\n");
667 if (br
->dev
->addr_assign_type
!= NET_ADDR_SET
) {
668 /* Ask for permission to use this MAC address now, even if we
669 * don't end up choosing it below.
671 err
= dev_pre_changeaddr_notify(br
->dev
, dev
->dev_addr
, extack
);
676 err
= nbp_vlan_init(p
, extack
);
678 netdev_err(dev
, "failed to initialize vlan filtering on this port\n");
682 spin_lock_bh(&br
->lock
);
683 changed_addr
= br_stp_recalculate_bridge_id(br
);
685 if (netif_running(dev
) && netif_oper_up(dev
) &&
686 (br
->dev
->flags
& IFF_UP
))
687 br_stp_enable_port(p
);
688 spin_unlock_bh(&br
->lock
);
690 br_ifinfo_notify(RTM_NEWLINK
, NULL
, p
);
693 call_netdevice_notifiers(NETDEV_CHANGEADDR
, br
->dev
);
695 br_mtu_auto_adjust(br
);
696 br_set_gso_limits(br
);
698 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
703 list_del_rcu(&p
->list
);
704 br_fdb_delete_by_port(br
, p
, 0, 1);
705 nbp_update_port_count(br
);
707 netdev_upper_dev_unlink(dev
, br
->dev
);
709 dev
->priv_flags
&= ~IFF_BRIDGE_PORT
;
710 netdev_rx_handler_unregister(dev
);
712 br_netpoll_disable(p
);
714 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
716 kobject_put(&p
->kobj
);
717 dev_set_allmulti(dev
, -1);
723 /* called with RTNL */
724 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
726 struct net_bridge_port
*p
;
729 p
= br_port_get_rtnl(dev
);
730 if (!p
|| p
->br
!= br
)
733 /* Since more than one interface can be attached to a bridge,
734 * there still maybe an alternate path for netconsole to use;
735 * therefore there is no reason for a NETDEV_RELEASE event.
739 br_mtu_auto_adjust(br
);
740 br_set_gso_limits(br
);
742 spin_lock_bh(&br
->lock
);
743 changed_addr
= br_stp_recalculate_bridge_id(br
);
744 spin_unlock_bh(&br
->lock
);
747 call_netdevice_notifiers(NETDEV_CHANGEADDR
, br
->dev
);
749 netdev_update_features(br
->dev
);
754 void br_port_flags_change(struct net_bridge_port
*p
, unsigned long mask
)
756 struct net_bridge
*br
= p
->br
;
758 if (mask
& BR_AUTO_MASK
)
759 nbp_update_port_count(br
);
761 if (mask
& BR_NEIGH_SUPPRESS
)
762 br_recalculate_neigh_suppress_enabled(br
);
765 bool br_port_flag_is_set(const struct net_device
*dev
, unsigned long flag
)
767 struct net_bridge_port
*p
;
769 p
= br_port_get_rtnl_rcu(dev
);
773 return p
->flags
& flag
;
775 EXPORT_SYMBOL_GPL(br_port_flag_is_set
);