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
<= br_auto_port(p
))
157 br_port_clear_promisc(p
);
159 br_port_set_promisc(p
);
164 static void nbp_update_port_count(struct net_bridge
*br
)
166 struct net_bridge_port
*p
;
169 list_for_each_entry(p
, &br
->port_list
, list
) {
173 if (br
->auto_cnt
!= cnt
) {
175 br_manage_promisc(br
);
179 static void nbp_delete_promisc(struct net_bridge_port
*p
)
181 /* If port is currently promiscuous, unset promiscuity.
182 * Otherwise, it is a static port so remove all addresses
185 dev_set_allmulti(p
->dev
, -1);
186 if (br_promisc_port(p
))
187 dev_set_promiscuity(p
->dev
, -1);
189 br_fdb_unsync_static(p
->br
, p
);
192 static void release_nbp(struct kobject
*kobj
)
194 struct net_bridge_port
*p
195 = container_of(kobj
, struct net_bridge_port
, kobj
);
199 static struct kobj_type brport_ktype
= {
201 .sysfs_ops
= &brport_sysfs_ops
,
203 .release
= release_nbp
,
206 static void destroy_nbp(struct net_bridge_port
*p
)
208 struct net_device
*dev
= p
->dev
;
214 kobject_put(&p
->kobj
);
217 static void destroy_nbp_rcu(struct rcu_head
*head
)
219 struct net_bridge_port
*p
=
220 container_of(head
, struct net_bridge_port
, rcu
);
224 /* Delete port(interface) from bridge is done in two steps.
225 * via RCU. First step, marks device as down. That deletes
226 * all the timers and stops new packets from flowing through.
228 * Final cleanup doesn't occur until after all CPU's finished
229 * processing packets.
231 * Protected from multiple admin operations by RTNL mutex
233 static void del_nbp(struct net_bridge_port
*p
)
235 struct net_bridge
*br
= p
->br
;
236 struct net_device
*dev
= p
->dev
;
238 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
240 nbp_delete_promisc(p
);
242 spin_lock_bh(&br
->lock
);
243 br_stp_disable_port(p
);
244 spin_unlock_bh(&br
->lock
);
246 br_ifinfo_notify(RTM_DELLINK
, p
);
248 list_del_rcu(&p
->list
);
251 br_fdb_delete_by_port(br
, p
, 1);
252 nbp_update_port_count(br
);
254 dev
->priv_flags
&= ~IFF_BRIDGE_PORT
;
256 netdev_rx_handler_unregister(dev
);
258 netdev_upper_dev_unlink(dev
, br
->dev
);
260 br_multicast_del_port(p
);
262 kobject_uevent(&p
->kobj
, KOBJ_REMOVE
);
263 kobject_del(&p
->kobj
);
265 br_netpoll_disable(p
);
267 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
270 /* Delete bridge device */
271 void br_dev_delete(struct net_device
*dev
, struct list_head
*head
)
273 struct net_bridge
*br
= netdev_priv(dev
);
274 struct net_bridge_port
*p
, *n
;
276 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
280 br_fdb_delete_by_port(br
, NULL
, 1);
283 del_timer_sync(&br
->gc_timer
);
285 br_sysfs_delbr(br
->dev
);
286 unregister_netdevice_queue(br
->dev
, head
);
289 /* find an available port number */
290 static int find_portno(struct net_bridge
*br
)
293 struct net_bridge_port
*p
;
294 unsigned long *inuse
;
296 inuse
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
301 set_bit(0, inuse
); /* zero is reserved */
302 list_for_each_entry(p
, &br
->port_list
, list
) {
303 set_bit(p
->port_no
, inuse
);
305 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
308 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
311 /* called with RTNL but without bridge lock */
312 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
313 struct net_device
*dev
)
316 struct net_bridge_port
*p
;
318 index
= find_portno(br
);
320 return ERR_PTR(index
);
322 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
324 return ERR_PTR(-ENOMEM
);
329 p
->path_cost
= port_cost(dev
);
330 p
->priority
= 0x8000 >> BR_PORT_BITS
;
332 p
->flags
= BR_LEARNING
| BR_FLOOD
;
334 p
->state
= BR_STATE_DISABLED
;
335 br_stp_port_timer_init(p
);
336 br_multicast_add_port(p
);
341 int br_add_bridge(struct net
*net
, const char *name
)
343 struct net_device
*dev
;
346 dev
= alloc_netdev(sizeof(struct net_bridge
), name
,
352 dev_net_set(dev
, net
);
353 dev
->rtnl_link_ops
= &br_link_ops
;
355 res
= register_netdev(dev
);
361 int br_del_bridge(struct net
*net
, const char *name
)
363 struct net_device
*dev
;
367 dev
= __dev_get_by_name(net
, name
);
369 ret
= -ENXIO
; /* Could not find device */
371 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
372 /* Attempt to delete non bridge device! */
376 else if (dev
->flags
& IFF_UP
) {
377 /* Not shutdown yet. */
382 br_dev_delete(dev
, NULL
);
388 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
389 int br_min_mtu(const struct net_bridge
*br
)
391 const struct net_bridge_port
*p
;
396 if (list_empty(&br
->port_list
))
399 list_for_each_entry(p
, &br
->port_list
, list
) {
400 if (!mtu
|| p
->dev
->mtu
< mtu
)
408 * Recomputes features using slave's features
410 netdev_features_t
br_features_recompute(struct net_bridge
*br
,
411 netdev_features_t features
)
413 struct net_bridge_port
*p
;
414 netdev_features_t mask
;
416 if (list_empty(&br
->port_list
))
420 features
&= ~NETIF_F_ONE_FOR_ALL
;
422 list_for_each_entry(p
, &br
->port_list
, list
) {
423 features
= netdev_increment_features(features
,
424 p
->dev
->features
, mask
);
430 /* called with RTNL */
431 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
433 struct net_bridge_port
*p
;
437 /* Don't allow bridging non-ethernet like devices */
438 if ((dev
->flags
& IFF_LOOPBACK
) ||
439 dev
->type
!= ARPHRD_ETHER
|| dev
->addr_len
!= ETH_ALEN
||
440 !is_valid_ether_addr(dev
->dev_addr
))
443 /* No bridging of bridges */
444 if (dev
->netdev_ops
->ndo_start_xmit
== br_dev_xmit
)
447 /* Device is already being bridged */
448 if (br_port_exists(dev
))
451 /* No bridging devices that dislike that (e.g. wireless) */
452 if (dev
->priv_flags
& IFF_DONT_BRIDGE
)
455 p
= new_nbp(br
, dev
);
459 call_netdevice_notifiers(NETDEV_JOIN
, dev
);
461 err
= dev_set_allmulti(dev
, 1);
465 err
= kobject_init_and_add(&p
->kobj
, &brport_ktype
, &(dev
->dev
.kobj
),
466 SYSFS_BRIDGE_PORT_ATTR
);
470 err
= br_sysfs_addif(p
);
474 err
= br_netpoll_enable(p
);
478 err
= netdev_master_upper_dev_link(dev
, br
->dev
);
482 err
= netdev_rx_handler_register(dev
, br_handle_frame
, p
);
486 dev
->priv_flags
|= IFF_BRIDGE_PORT
;
488 dev_disable_lro(dev
);
490 list_add_rcu(&p
->list
, &br
->port_list
);
492 nbp_update_port_count(br
);
494 netdev_update_features(br
->dev
);
496 if (br
->dev
->needed_headroom
< dev
->needed_headroom
)
497 br
->dev
->needed_headroom
= dev
->needed_headroom
;
499 if (br_fdb_insert(br
, p
, dev
->dev_addr
, 0))
500 netdev_err(dev
, "failed insert local address bridge forwarding table\n");
502 spin_lock_bh(&br
->lock
);
503 changed_addr
= br_stp_recalculate_bridge_id(br
);
505 if (netif_running(dev
) && netif_oper_up(dev
) &&
506 (br
->dev
->flags
& IFF_UP
))
507 br_stp_enable_port(p
);
508 spin_unlock_bh(&br
->lock
);
510 br_ifinfo_notify(RTM_NEWLINK
, p
);
513 call_netdevice_notifiers(NETDEV_CHANGEADDR
, br
->dev
);
515 dev_set_mtu(br
->dev
, br_min_mtu(br
));
517 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
522 netdev_upper_dev_unlink(dev
, br
->dev
);
524 br_netpoll_disable(p
);
526 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
528 kobject_put(&p
->kobj
);
529 p
= NULL
; /* kobject_put frees */
531 dev_set_allmulti(dev
, -1);
538 /* called with RTNL */
539 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
541 struct net_bridge_port
*p
;
544 p
= br_port_get_rtnl(dev
);
545 if (!p
|| p
->br
!= br
)
548 /* Since more than one interface can be attached to a bridge,
549 * there still maybe an alternate path for netconsole to use;
550 * therefore there is no reason for a NETDEV_RELEASE event.
554 spin_lock_bh(&br
->lock
);
555 changed_addr
= br_stp_recalculate_bridge_id(br
);
556 spin_unlock_bh(&br
->lock
);
559 call_netdevice_notifiers(NETDEV_CHANGEADDR
, br
->dev
);
561 netdev_update_features(br
->dev
);
566 void br_port_flags_change(struct net_bridge_port
*p
, unsigned long mask
)
568 struct net_bridge
*br
= p
->br
;
570 if (mask
& BR_AUTO_MASK
)
571 nbp_update_port_count(br
);