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/netpoll.h>
17 #include <linux/ethtool.h>
18 #include <linux/if_arp.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/if_ether.h>
23 #include <linux/slab.h>
26 #include "br_private.h"
29 #include <ctf/hndctf.h>
33 * Determine initial path cost based on speed.
34 * using recommendations from 802.1d standard
36 * Since driver might sleep need to not be holding any locks.
38 static int port_cost(struct net_device
*dev
)
40 if (dev
->ethtool_ops
&& dev
->ethtool_ops
->get_settings
) {
41 struct ethtool_cmd ecmd
= { .cmd
= ETHTOOL_GSET
, };
43 if (!dev
->ethtool_ops
->get_settings(dev
, &ecmd
)) {
57 /* Old silly heuristics based on name */
58 if (!strncmp(dev
->name
, "lec", 3))
61 if (!strncmp(dev
->name
, "plip", 4))
64 return 100; /* assume old 10Mbps */
69 * Check for port carrier transistions.
70 * Called from work queue to allow for calling functions that
71 * might sleep (such as speed check), and to debounce.
73 void br_port_carrier_check(struct net_bridge_port
*p
)
75 struct net_device
*dev
= p
->dev
;
76 struct net_bridge
*br
= p
->br
;
78 if (netif_carrier_ok(dev
))
79 p
->path_cost
= port_cost(dev
);
81 if (netif_running(br
->dev
)) {
82 spin_lock_bh(&br
->lock
);
83 if (netif_carrier_ok(dev
)) {
84 if (p
->state
== BR_STATE_DISABLED
)
85 br_stp_enable_port(p
);
87 if (p
->state
!= BR_STATE_DISABLED
)
88 br_stp_disable_port(p
);
90 spin_unlock_bh(&br
->lock
);
94 static void release_nbp(struct kobject
*kobj
)
96 struct net_bridge_port
*p
97 = container_of(kobj
, struct net_bridge_port
, kobj
);
101 static struct kobj_type brport_ktype
= {
103 .sysfs_ops
= &brport_sysfs_ops
,
105 .release
= release_nbp
,
108 static void destroy_nbp(struct net_bridge_port
*p
)
110 struct net_device
*dev
= p
->dev
;
116 kobject_put(&p
->kobj
);
119 static void destroy_nbp_rcu(struct rcu_head
*head
)
121 struct net_bridge_port
*p
=
122 container_of(head
, struct net_bridge_port
, rcu
);
126 /* Delete port(interface) from bridge is done in two steps.
127 * via RCU. First step, marks device as down. That deletes
128 * all the timers and stops new packets from flowing through.
130 * Final cleanup doesn't occur until after all CPU's finished
131 * processing packets.
133 * Protected from multiple admin operations by RTNL mutex
135 static void del_nbp(struct net_bridge_port
*p
)
137 struct net_bridge
*br
= p
->br
;
138 struct net_device
*dev
= p
->dev
;
140 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
142 dev_set_promiscuity(dev
, -1);
144 spin_lock_bh(&br
->lock
);
145 br_stp_disable_port(p
);
146 spin_unlock_bh(&br
->lock
);
148 br_ifinfo_notify(RTM_DELLINK
, p
);
150 br_fdb_delete_by_port(br
, p
, 1);
152 list_del_rcu(&p
->list
);
154 dev
->priv_flags
&= ~IFF_BRIDGE_PORT
;
156 netdev_rx_handler_unregister(dev
);
158 br_multicast_del_port(p
);
160 kobject_uevent(&p
->kobj
, KOBJ_REMOVE
);
161 kobject_del(&p
->kobj
);
163 br_netpoll_disable(p
);
165 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
168 /* called with RTNL */
169 static void del_br(struct net_bridge
*br
, struct list_head
*head
)
171 struct net_bridge_port
*p
, *n
;
173 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
177 del_timer_sync(&br
->gc_timer
);
179 br_sysfs_delbr(br
->dev
);
180 unregister_netdevice_queue(br
->dev
, head
);
183 static struct net_device
*new_bridge_dev(struct net
*net
, const char *name
)
185 struct net_bridge
*br
;
186 struct net_device
*dev
;
188 dev
= alloc_netdev(sizeof(struct net_bridge
), name
,
193 dev_net_set(dev
, net
);
195 br
= netdev_priv(dev
);
198 br
->stats
= alloc_percpu(struct br_cpu_netstats
);
204 spin_lock_init(&br
->lock
);
205 INIT_LIST_HEAD(&br
->port_list
);
206 spin_lock_init(&br
->hash_lock
);
208 br
->bridge_id
.prio
[0] = 0x80;
209 br
->bridge_id
.prio
[1] = 0x00;
211 memcpy(br
->group_addr
, br_group_address
, ETH_ALEN
);
213 br
->feature_mask
= dev
->features
;
214 br
->stp_enabled
= BR_NO_STP
;
215 br
->designated_root
= br
->bridge_id
;
216 br
->root_path_cost
= 0;
218 br
->bridge_max_age
= br
->max_age
= 20 * HZ
;
219 br
->bridge_hello_time
= br
->hello_time
= 2 * HZ
;
220 br
->bridge_forward_delay
= br
->forward_delay
= 15 * HZ
;
221 br
->topology_change
= 0;
222 br
->topology_change_detected
= 0;
223 br
->ageing_time
= 300 * HZ
;
225 br_netfilter_rtable_init(br
);
227 br_stp_timer_init(br
);
228 br_multicast_init(br
);
233 /* find an available port number */
234 static int find_portno(struct net_bridge
*br
)
237 struct net_bridge_port
*p
;
238 unsigned long *inuse
;
240 inuse
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
245 set_bit(0, inuse
); /* zero is reserved */
246 list_for_each_entry(p
, &br
->port_list
, list
) {
247 set_bit(p
->port_no
, inuse
);
249 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
252 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
255 /* called with RTNL but without bridge lock */
256 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
257 struct net_device
*dev
)
260 struct net_bridge_port
*p
;
262 index
= find_portno(br
);
264 return ERR_PTR(index
);
266 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
268 return ERR_PTR(-ENOMEM
);
273 p
->path_cost
= port_cost(dev
);
274 p
->priority
= 0x8000 >> BR_PORT_BITS
;
278 p
->state
= BR_STATE_DISABLED
;
279 br_stp_port_timer_init(p
);
280 br_multicast_add_port(p
);
285 static struct device_type br_type
= {
289 int br_add_bridge(struct net
*net
, const char *name
)
291 struct net_device
*dev
;
294 dev
= new_bridge_dev(net
, name
);
299 if (strchr(dev
->name
, '%')) {
300 ret
= dev_alloc_name(dev
, dev
->name
);
305 SET_NETDEV_DEVTYPE(dev
, &br_type
);
307 ret
= register_netdevice(dev
);
312 if ((ctf_dev_register(kcih
, dev
, TRUE
) != BCME_OK
) ||
313 (ctf_enable(kcih
, dev
, TRUE
, NULL
) != BCME_OK
)) {
314 ctf_dev_unregister(kcih
, dev
);
315 unregister_netdevice(dev
);
321 ret
= br_sysfs_addbr(dev
);
323 unregister_netdevice(dev
);
333 int br_del_bridge(struct net
*net
, const char *name
)
335 struct net_device
*dev
;
339 dev
= __dev_get_by_name(net
, name
);
341 ret
= -ENXIO
; /* Could not find device */
343 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
344 /* Attempt to delete non bridge device! */
348 else if (dev
->flags
& IFF_UP
) {
349 /* Not shutdown yet. */
355 ctf_dev_unregister(kcih
, dev
);
357 del_br(netdev_priv(dev
), NULL
);
364 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
365 int br_min_mtu(const struct net_bridge
*br
)
367 const struct net_bridge_port
*p
;
372 if (list_empty(&br
->port_list
))
375 list_for_each_entry(p
, &br
->port_list
, list
) {
376 if (!mtu
|| p
->dev
->mtu
< mtu
)
384 * Recomputes features using slave's features
386 void br_features_recompute(struct net_bridge
*br
)
388 struct net_bridge_port
*p
;
389 unsigned long features
, mask
;
391 features
= mask
= br
->feature_mask
;
392 if (list_empty(&br
->port_list
))
395 features
&= ~NETIF_F_ONE_FOR_ALL
;
397 list_for_each_entry(p
, &br
->port_list
, list
) {
398 features
= netdev_increment_features(features
,
399 p
->dev
->features
, mask
);
403 br
->dev
->features
= netdev_fix_features(features
, NULL
);
406 /* called with RTNL */
407 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
409 struct net_bridge_port
*p
;
412 /* Don't allow bridging non-ethernet like devices */
413 if ((dev
->flags
& IFF_LOOPBACK
) ||
414 dev
->type
!= ARPHRD_ETHER
|| dev
->addr_len
!= ETH_ALEN
)
417 /* No bridging of bridges */
418 if (dev
->netdev_ops
->ndo_start_xmit
== br_dev_xmit
)
421 /* Device is already being bridged */
422 if (br_port_exists(dev
))
425 /* No bridging devices that dislike that (e.g. wireless) */
426 if (dev
->priv_flags
& IFF_DONT_BRIDGE
)
429 p
= new_nbp(br
, dev
);
433 err
= dev_set_promiscuity(dev
, 1);
437 err
= kobject_init_and_add(&p
->kobj
, &brport_ktype
, &(dev
->dev
.kobj
),
438 SYSFS_BRIDGE_PORT_ATTR
);
442 err
= br_fdb_insert(br
, p
, dev
->dev_addr
);
446 err
= br_sysfs_addif(p
);
450 if (br_netpoll_info(br
) && ((err
= br_netpoll_enable(p
))))
453 err
= netdev_rx_handler_register(dev
, br_handle_frame
, p
);
457 dev
->priv_flags
|= IFF_BRIDGE_PORT
;
459 dev_disable_lro(dev
);
461 list_add_rcu(&p
->list
, &br
->port_list
);
463 spin_lock_bh(&br
->lock
);
464 br_stp_recalculate_bridge_id(br
);
465 br_features_recompute(br
);
467 if ((dev
->flags
& IFF_UP
) && netif_carrier_ok(dev
) &&
468 (br
->dev
->flags
& IFF_UP
))
469 br_stp_enable_port(p
);
470 spin_unlock_bh(&br
->lock
);
472 br_ifinfo_notify(RTM_NEWLINK
, p
);
474 dev_set_mtu(br
->dev
, br_min_mtu(br
));
476 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
480 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
482 br_fdb_delete_by_port(br
, p
, 1);
484 kobject_put(&p
->kobj
);
485 p
= NULL
; /* kobject_put frees */
487 dev_set_promiscuity(dev
, -1);
494 /* called with RTNL */
495 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
497 struct net_bridge_port
*p
;
499 if (!br_port_exists(dev
))
502 p
= br_port_get(dev
);
508 spin_lock_bh(&br
->lock
);
509 br_stp_recalculate_bridge_id(br
);
510 br_features_recompute(br
);
511 spin_unlock_bh(&br
->lock
);
516 void __net_exit
br_net_exit(struct net
*net
)
518 struct net_device
*dev
;
522 for_each_netdev(net
, dev
)
523 if (dev
->priv_flags
& IFF_EBRIDGE
)
524 del_br(netdev_priv(dev
), &list
);
526 unregister_netdevice_many(&list
);