3 * Linux ethernet bridge
6 * Lennert Buytenhek <buytenh@gnu.org>
8 * $Id: br_if.c,v 1.7 2001/12/24 00:59:55 davem Exp $
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
16 #include <linux/kernel.h>
17 #include <linux/netdevice.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>
26 #include "br_private.h"
29 #include <ctf/hndctf.h>
34 * Determine initial path cost based on speed.
35 * using recommendations from 802.1d standard
37 * Need to simulate user ioctl because not all device's that support
38 * ethtool, use ethtool_ops. Also, since driver might sleep need to
39 * not be holding any locks.
41 static int port_cost(struct net_device
*dev
)
43 struct ethtool_cmd ecmd
= { ETHTOOL_GSET
};
48 strncpy(ifr
.ifr_name
, dev
->name
, IFNAMSIZ
);
49 ifr
.ifr_data
= (void __user
*) &ecmd
;
53 err
= dev_ethtool(&ifr
);
69 /* Old silly heuristics based on name */
70 if (!strncmp(dev
->name
, "lec", 3))
73 if (!strncmp(dev
->name
, "plip", 4))
76 return 100; /* assume old 10Mbps */
81 * Check for port carrier transistions.
82 * Called from work queue to allow for calling functions that
83 * might sleep (such as speed check), and to debounce.
85 void br_port_carrier_check(struct net_bridge_port
*p
)
87 struct net_device
*dev
= p
->dev
;
88 struct net_bridge
*br
= p
->br
;
90 if (netif_carrier_ok(dev
))
91 p
->path_cost
= port_cost(dev
);
93 if (netif_running(br
->dev
)) {
94 spin_lock_bh(&br
->lock
);
95 if (netif_carrier_ok(dev
)) {
96 if (p
->state
== BR_STATE_DISABLED
)
97 br_stp_enable_port(p
);
99 if (p
->state
!= BR_STATE_DISABLED
)
100 br_stp_disable_port(p
);
102 spin_unlock_bh(&br
->lock
);
106 static void release_nbp(struct kobject
*kobj
)
108 struct net_bridge_port
*p
109 = container_of(kobj
, struct net_bridge_port
, kobj
);
113 static struct kobj_type brport_ktype
= {
115 .sysfs_ops
= &brport_sysfs_ops
,
117 .release
= release_nbp
,
120 static void destroy_nbp(struct net_bridge_port
*p
)
122 struct net_device
*dev
= p
->dev
;
128 kobject_put(&p
->kobj
);
131 static void destroy_nbp_rcu(struct rcu_head
*head
)
133 struct net_bridge_port
*p
=
134 container_of(head
, struct net_bridge_port
, rcu
);
138 /* Delete port(interface) from bridge is done in two steps.
139 * via RCU. First step, marks device as down. That deletes
140 * all the timers and stops new packets from flowing through.
142 * Final cleanup doesn't occur until after all CPU's finished
143 * processing packets.
145 * Protected from multiple admin operations by RTNL mutex
147 static void del_nbp(struct net_bridge_port
*p
)
149 struct net_bridge
*br
= p
->br
;
150 struct net_device
*dev
= p
->dev
;
152 sysfs_remove_link(&br
->ifobj
, dev
->name
);
154 dev_set_promiscuity(dev
, -1);
156 spin_lock_bh(&br
->lock
);
157 br_stp_disable_port(p
);
158 spin_unlock_bh(&br
->lock
);
160 br_ifinfo_notify(RTM_DELLINK
, p
);
162 br_fdb_delete_by_port(br
, p
, 1);
164 list_del_rcu(&p
->list
);
166 rcu_assign_pointer(dev
->br_port
, NULL
);
168 kobject_uevent(&p
->kobj
, KOBJ_REMOVE
);
169 kobject_del(&p
->kobj
);
171 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
174 /* called with RTNL */
175 static void del_br(struct net_bridge
*br
)
177 struct net_bridge_port
*p
, *n
;
179 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
183 del_timer_sync(&br
->gc_timer
);
185 br_sysfs_delbr(br
->dev
);
186 unregister_netdevice(br
->dev
);
189 static struct net_device
*new_bridge_dev(const char *name
)
191 struct net_bridge
*br
;
192 struct net_device
*dev
;
194 dev
= alloc_netdev(sizeof(struct net_bridge
), name
,
200 br
= netdev_priv(dev
);
203 spin_lock_init(&br
->lock
);
204 INIT_LIST_HEAD(&br
->port_list
);
205 spin_lock_init(&br
->hash_lock
);
207 br
->bridge_id
.prio
[0] = 0x80;
208 br
->bridge_id
.prio
[1] = 0x00;
210 memcpy(br
->group_addr
, br_group_address
, ETH_ALEN
);
212 br
->feature_mask
= dev
->features
;
213 br
->stp_enabled
= BR_NO_STP
;
214 br
->designated_root
= br
->bridge_id
;
215 br
->root_path_cost
= 0;
217 br
->bridge_max_age
= br
->max_age
= 20 * HZ
;
218 br
->bridge_hello_time
= br
->hello_time
= 2 * HZ
;
219 br
->bridge_forward_delay
= br
->forward_delay
= 15 * HZ
;
220 br
->topology_change
= 0;
221 br
->topology_change_detected
= 0;
222 br
->ageing_time
= 300 * HZ
;
223 INIT_LIST_HEAD(&br
->age_list
);
225 br_stp_timer_init(br
);
230 /* find an available port number */
231 static int find_portno(struct net_bridge
*br
)
234 struct net_bridge_port
*p
;
235 unsigned long *inuse
;
237 inuse
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
242 set_bit(0, inuse
); /* zero is reserved */
243 list_for_each_entry(p
, &br
->port_list
, list
) {
244 set_bit(p
->port_no
, inuse
);
246 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
249 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
252 /* called with RTNL but without bridge lock */
253 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
254 struct net_device
*dev
)
257 struct net_bridge_port
*p
;
259 index
= find_portno(br
);
261 return ERR_PTR(index
);
263 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
265 return ERR_PTR(-ENOMEM
);
270 p
->path_cost
= port_cost(dev
);
271 p
->priority
= 0x8000 >> BR_PORT_BITS
;
274 p
->state
= BR_STATE_DISABLED
;
275 br_stp_port_timer_init(p
);
277 kobject_init(&p
->kobj
);
278 kobject_set_name(&p
->kobj
, SYSFS_BRIDGE_PORT_ATTR
);
279 p
->kobj
.ktype
= &brport_ktype
;
280 p
->kobj
.parent
= &(dev
->dev
.kobj
);
286 int br_add_bridge(const char *name
)
288 struct net_device
*dev
;
291 dev
= new_bridge_dev(name
);
296 if (strchr(dev
->name
, '%')) {
297 ret
= dev_alloc_name(dev
, dev
->name
);
304 ret
= register_netdevice(dev
);
309 if ((ctf_dev_register(kcih
, dev
, TRUE
) != BCME_OK
) ||
310 (ctf_enable(kcih
, dev
, TRUE
) != BCME_OK
)) {
311 ctf_dev_unregister(kcih
, dev
);
312 unregister_netdevice(dev
);
318 ret
= br_sysfs_addbr(dev
);
320 unregister_netdevice(dev
);
326 int br_del_bridge(const char *name
)
328 struct net_device
*dev
;
332 dev
= __dev_get_by_name(name
);
334 ret
= -ENXIO
; /* Could not find device */
336 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
337 /* Attempt to delete non bridge device! */
341 else if (dev
->flags
& IFF_UP
) {
342 /* Not shutdown yet. */
348 ctf_dev_unregister(kcih
, dev
);
350 del_br(netdev_priv(dev
));
357 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
358 int br_min_mtu(const struct net_bridge
*br
)
360 const struct net_bridge_port
*p
;
365 if (list_empty(&br
->port_list
))
368 list_for_each_entry(p
, &br
->port_list
, list
) {
369 if (!mtu
|| p
->dev
->mtu
< mtu
)
377 * Recomputes features using slave's features
379 void br_features_recompute(struct net_bridge
*br
)
381 struct net_bridge_port
*p
;
382 unsigned long features
;
384 features
= br
->feature_mask
;
386 list_for_each_entry(p
, &br
->port_list
, list
) {
387 features
= netdev_compute_features(features
, p
->dev
->features
);
390 br
->dev
->features
= features
;
393 /* called with RTNL */
394 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
396 struct net_bridge_port
*p
;
399 if (dev
->flags
& IFF_LOOPBACK
|| dev
->type
!= ARPHRD_ETHER
)
402 if (dev
->hard_start_xmit
== br_dev_xmit
)
405 if (dev
->br_port
!= NULL
)
408 p
= new_nbp(br
, dev
);
412 err
= kobject_add(&p
->kobj
);
416 err
= br_fdb_insert(br
, p
, dev
->dev_addr
);
420 err
= br_sysfs_addif(p
);
424 rcu_assign_pointer(dev
->br_port
, p
);
425 dev_set_promiscuity(dev
, 1);
427 list_add_rcu(&p
->list
, &br
->port_list
);
429 spin_lock_bh(&br
->lock
);
430 br_stp_recalculate_bridge_id(br
);
431 br_features_recompute(br
);
433 if ((dev
->flags
& IFF_UP
) && netif_carrier_ok(dev
) &&
434 (br
->dev
->flags
& IFF_UP
))
435 br_stp_enable_port(p
);
436 spin_unlock_bh(&br
->lock
);
438 br_ifinfo_notify(RTM_NEWLINK
, p
);
440 dev_set_mtu(br
->dev
, br_min_mtu(br
));
442 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
446 br_fdb_delete_by_port(br
, p
, 1);
448 kobject_del(&p
->kobj
);
450 kobject_put(&p
->kobj
);
454 /* called with RTNL */
455 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
457 struct net_bridge_port
*p
= dev
->br_port
;
459 if (!p
|| p
->br
!= br
)
464 spin_lock_bh(&br
->lock
);
465 br_stp_recalculate_bridge_id(br
);
466 br_features_recompute(br
);
467 spin_unlock_bh(&br
->lock
);
472 void __exit
br_cleanup_bridges(void)
474 struct net_device
*dev
, *nxt
;
477 for_each_netdev_safe(dev
, nxt
)
478 if (dev
->priv_flags
& IFF_EBRIDGE
)