3 * Linux ethernet bridge
6 * Lennert Buytenhek <buytenh@gnu.org>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
14 #include <linux/kernel.h>
15 #include <linux/netdevice.h>
16 #include <linux/etherdevice.h>
17 #include <linux/netpoll.h>
18 #include <linux/ethtool.h>
19 #include <linux/if_arp.h>
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/rtnetlink.h>
23 #include <linux/if_ether.h>
24 #include <linux/slab.h>
26 #include <linux/if_vlan.h>
28 #include "br_private.h"
31 * Determine initial path cost based on speed.
32 * using recommendations from 802.1d standard
34 * Since driver might sleep need to not be holding any locks.
36 static int port_cost(struct net_device
*dev
)
38 struct ethtool_cmd ecmd
;
40 if (!__ethtool_get_settings(dev
, &ecmd
)) {
41 switch (ethtool_cmd_speed(&ecmd
)) {
53 /* Old silly heuristics based on name */
54 if (!strncmp(dev
->name
, "lec", 3))
57 if (!strncmp(dev
->name
, "plip", 4))
60 return 100; /* assume old 10Mbps */
64 /* Check for port carrier transitions. */
65 void br_port_carrier_check(struct net_bridge_port
*p
)
67 struct net_device
*dev
= p
->dev
;
68 struct net_bridge
*br
= p
->br
;
70 if (!(p
->flags
& BR_ADMIN_COST
) &&
71 netif_running(dev
) && netif_oper_up(dev
))
72 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
);
82 if (p
->state
!= BR_STATE_DISABLED
)
83 br_stp_disable_port(p
);
85 spin_unlock_bh(&br
->lock
);
88 static void br_port_set_promisc(struct net_bridge_port
*p
)
92 if (br_promisc_port(p
))
95 err
= dev_set_promiscuity(p
->dev
, 1);
99 br_fdb_unsync_static(p
->br
, p
);
100 p
->flags
|= BR_PROMISC
;
103 static void br_port_clear_promisc(struct net_bridge_port
*p
)
107 /* Check if the port is already non-promisc or if it doesn't
108 * support UNICAST filtering. Without unicast filtering support
109 * we'll end up re-enabling promisc mode anyway, so just check for
112 if (!br_promisc_port(p
) || !(p
->dev
->priv_flags
& IFF_UNICAST_FLT
))
115 /* Since we'll be clearing the promisc mode, program the port
116 * first so that we don't have interruption in traffic.
118 err
= br_fdb_sync_static(p
->br
, p
);
122 dev_set_promiscuity(p
->dev
, -1);
123 p
->flags
&= ~BR_PROMISC
;
126 /* When a port is added or removed or when certain port flags
127 * change, this function is called to automatically manage
128 * promiscuity setting of all the bridge ports. We are always called
129 * under RTNL so can skip using rcu primitives.
131 void br_manage_promisc(struct net_bridge
*br
)
133 struct net_bridge_port
*p
;
134 bool set_all
= false;
136 /* If vlan filtering is disabled or bridge interface is placed
137 * into promiscuous mode, place all ports in promiscuous mode.
139 if ((br
->dev
->flags
& IFF_PROMISC
) || !br_vlan_enabled(br
))
142 list_for_each_entry(p
, &br
->port_list
, list
) {
144 br_port_set_promisc(p
);
146 /* If the number of auto-ports is <= 1, then all other
147 * ports will have their output configuration
148 * statically specified through fdbs. Since ingress
149 * on the auto-port becomes forwarding/egress to other
150 * ports and egress configuration is statically known,
151 * we can say that ingress configuration of the
152 * auto-port is also statically known.
153 * This lets us disable promiscuous mode and write
156 if (br
->auto_cnt
== 0 ||
157 (br
->auto_cnt
== 1 && br_auto_port(p
)))
158 br_port_clear_promisc(p
);
160 br_port_set_promisc(p
);
165 static void nbp_update_port_count(struct net_bridge
*br
)
167 struct net_bridge_port
*p
;
170 list_for_each_entry(p
, &br
->port_list
, list
) {
174 if (br
->auto_cnt
!= cnt
) {
176 br_manage_promisc(br
);
180 static void nbp_delete_promisc(struct net_bridge_port
*p
)
182 /* If port is currently promiscuous, unset promiscuity.
183 * Otherwise, it is a static port so remove all addresses
186 dev_set_allmulti(p
->dev
, -1);
187 if (br_promisc_port(p
))
188 dev_set_promiscuity(p
->dev
, -1);
190 br_fdb_unsync_static(p
->br
, p
);
193 static void release_nbp(struct kobject
*kobj
)
195 struct net_bridge_port
*p
196 = container_of(kobj
, struct net_bridge_port
, kobj
);
200 static struct kobj_type brport_ktype
= {
202 .sysfs_ops
= &brport_sysfs_ops
,
204 .release
= release_nbp
,
207 static void destroy_nbp(struct net_bridge_port
*p
)
209 struct net_device
*dev
= p
->dev
;
215 kobject_put(&p
->kobj
);
218 static void destroy_nbp_rcu(struct rcu_head
*head
)
220 struct net_bridge_port
*p
=
221 container_of(head
, struct net_bridge_port
, rcu
);
225 /* Delete port(interface) from bridge is done in two steps.
226 * via RCU. First step, marks device as down. That deletes
227 * all the timers and stops new packets from flowing through.
229 * Final cleanup doesn't occur until after all CPU's finished
230 * processing packets.
232 * Protected from multiple admin operations by RTNL mutex
234 static void del_nbp(struct net_bridge_port
*p
)
236 struct net_bridge
*br
= p
->br
;
237 struct net_device
*dev
= p
->dev
;
239 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
241 nbp_delete_promisc(p
);
243 spin_lock_bh(&br
->lock
);
244 br_stp_disable_port(p
);
245 spin_unlock_bh(&br
->lock
);
247 br_ifinfo_notify(RTM_DELLINK
, p
);
249 list_del_rcu(&p
->list
);
252 br_fdb_delete_by_port(br
, p
, 1);
253 nbp_update_port_count(br
);
255 netdev_upper_dev_unlink(dev
, br
->dev
);
257 dev
->priv_flags
&= ~IFF_BRIDGE_PORT
;
259 netdev_rx_handler_unregister(dev
);
261 br_multicast_del_port(p
);
263 kobject_uevent(&p
->kobj
, KOBJ_REMOVE
);
264 kobject_del(&p
->kobj
);
266 br_netpoll_disable(p
);
268 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
271 /* Delete bridge device */
272 void br_dev_delete(struct net_device
*dev
, struct list_head
*head
)
274 struct net_bridge
*br
= netdev_priv(dev
);
275 struct net_bridge_port
*p
, *n
;
277 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
281 br_fdb_delete_by_port(br
, NULL
, 1);
284 del_timer_sync(&br
->gc_timer
);
286 br_sysfs_delbr(br
->dev
);
287 unregister_netdevice_queue(br
->dev
, head
);
290 /* find an available port number */
291 static int find_portno(struct net_bridge
*br
)
294 struct net_bridge_port
*p
;
295 unsigned long *inuse
;
297 inuse
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
302 set_bit(0, inuse
); /* zero is reserved */
303 list_for_each_entry(p
, &br
->port_list
, list
) {
304 set_bit(p
->port_no
, inuse
);
306 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
309 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
312 /* called with RTNL but without bridge lock */
313 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
314 struct net_device
*dev
)
317 struct net_bridge_port
*p
;
319 index
= find_portno(br
);
321 return ERR_PTR(index
);
323 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
325 return ERR_PTR(-ENOMEM
);
330 p
->path_cost
= port_cost(dev
);
331 p
->priority
= 0x8000 >> BR_PORT_BITS
;
333 p
->flags
= BR_LEARNING
| BR_FLOOD
;
335 br_set_state(p
, BR_STATE_DISABLED
);
336 br_stp_port_timer_init(p
);
337 br_multicast_add_port(p
);
342 int br_add_bridge(struct net
*net
, const char *name
)
344 struct net_device
*dev
;
347 dev
= alloc_netdev(sizeof(struct net_bridge
), name
, NET_NAME_UNKNOWN
,
353 dev_net_set(dev
, net
);
354 dev
->rtnl_link_ops
= &br_link_ops
;
356 res
= register_netdev(dev
);
362 int br_del_bridge(struct net
*net
, const char *name
)
364 struct net_device
*dev
;
368 dev
= __dev_get_by_name(net
, name
);
370 ret
= -ENXIO
; /* Could not find device */
372 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
373 /* Attempt to delete non bridge device! */
377 else if (dev
->flags
& IFF_UP
) {
378 /* Not shutdown yet. */
383 br_dev_delete(dev
, NULL
);
389 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
390 int br_min_mtu(const struct net_bridge
*br
)
392 const struct net_bridge_port
*p
;
397 if (list_empty(&br
->port_list
))
400 list_for_each_entry(p
, &br
->port_list
, list
) {
401 if (!mtu
|| p
->dev
->mtu
< mtu
)
409 * Recomputes features using slave's features
411 netdev_features_t
br_features_recompute(struct net_bridge
*br
,
412 netdev_features_t features
)
414 struct net_bridge_port
*p
;
415 netdev_features_t mask
;
417 if (list_empty(&br
->port_list
))
421 features
&= ~NETIF_F_ONE_FOR_ALL
;
423 list_for_each_entry(p
, &br
->port_list
, list
) {
424 features
= netdev_increment_features(features
,
425 p
->dev
->features
, mask
);
427 features
= netdev_add_tso_features(features
, mask
);
432 /* called with RTNL */
433 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
435 struct net_bridge_port
*p
;
439 /* Don't allow bridging non-ethernet like devices, or DSA-enabled
440 * master network devices since the bridge layer rx_handler prevents
441 * the DSA fake ethertype handler to be invoked, so we do not strip off
442 * the DSA switch tag protocol header and the bridge layer just return
443 * RX_HANDLER_CONSUMED, stopping RX processing for these frames.
445 if ((dev
->flags
& IFF_LOOPBACK
) ||
446 dev
->type
!= ARPHRD_ETHER
|| dev
->addr_len
!= ETH_ALEN
||
447 !is_valid_ether_addr(dev
->dev_addr
) ||
448 netdev_uses_dsa(dev
))
451 /* No bridging of bridges */
452 if (dev
->netdev_ops
->ndo_start_xmit
== br_dev_xmit
)
455 /* Device is already being bridged */
456 if (br_port_exists(dev
))
459 /* No bridging devices that dislike that (e.g. wireless) */
460 if (dev
->priv_flags
& IFF_DONT_BRIDGE
)
463 p
= new_nbp(br
, dev
);
467 call_netdevice_notifiers(NETDEV_JOIN
, dev
);
469 err
= dev_set_allmulti(dev
, 1);
473 err
= kobject_init_and_add(&p
->kobj
, &brport_ktype
, &(dev
->dev
.kobj
),
474 SYSFS_BRIDGE_PORT_ATTR
);
478 err
= br_sysfs_addif(p
);
482 err
= br_netpoll_enable(p
);
486 err
= netdev_rx_handler_register(dev
, br_handle_frame
, p
);
490 dev
->priv_flags
|= IFF_BRIDGE_PORT
;
492 err
= netdev_master_upper_dev_link(dev
, br
->dev
);
496 dev_disable_lro(dev
);
498 list_add_rcu(&p
->list
, &br
->port_list
);
500 nbp_update_port_count(br
);
502 netdev_update_features(br
->dev
);
504 if (br
->dev
->needed_headroom
< dev
->needed_headroom
)
505 br
->dev
->needed_headroom
= dev
->needed_headroom
;
507 if (br_fdb_insert(br
, p
, dev
->dev_addr
, 0))
508 netdev_err(dev
, "failed insert local address bridge forwarding table\n");
510 if (nbp_vlan_init(p
))
511 netdev_err(dev
, "failed to initialize vlan filtering on this port\n");
513 spin_lock_bh(&br
->lock
);
514 changed_addr
= br_stp_recalculate_bridge_id(br
);
516 if (netif_running(dev
) && netif_oper_up(dev
) &&
517 (br
->dev
->flags
& IFF_UP
))
518 br_stp_enable_port(p
);
519 spin_unlock_bh(&br
->lock
);
521 br_ifinfo_notify(RTM_NEWLINK
, p
);
524 call_netdevice_notifiers(NETDEV_CHANGEADDR
, br
->dev
);
526 dev_set_mtu(br
->dev
, br_min_mtu(br
));
528 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
533 dev
->priv_flags
&= ~IFF_BRIDGE_PORT
;
534 netdev_rx_handler_unregister(dev
);
536 br_netpoll_disable(p
);
538 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
540 kobject_put(&p
->kobj
);
541 p
= NULL
; /* kobject_put frees */
543 dev_set_allmulti(dev
, -1);
550 /* called with RTNL */
551 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
553 struct net_bridge_port
*p
;
556 p
= br_port_get_rtnl(dev
);
557 if (!p
|| p
->br
!= br
)
560 /* Since more than one interface can be attached to a bridge,
561 * there still maybe an alternate path for netconsole to use;
562 * therefore there is no reason for a NETDEV_RELEASE event.
566 spin_lock_bh(&br
->lock
);
567 changed_addr
= br_stp_recalculate_bridge_id(br
);
568 spin_unlock_bh(&br
->lock
);
571 call_netdevice_notifiers(NETDEV_CHANGEADDR
, br
->dev
);
573 netdev_update_features(br
->dev
);
578 void br_port_flags_change(struct net_bridge_port
*p
, unsigned long mask
)
580 struct net_bridge
*br
= p
->br
;
582 if (mask
& BR_AUTO_MASK
)
583 nbp_update_port_count(br
);