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 * Determine initial path cost based on speed.
30 * using recommendations from 802.1d standard
32 * Need to simulate user ioctl because not all device's that support
33 * ethtool, use ethtool_ops. Also, since driver might sleep need to
34 * not be holding any locks.
36 static int port_cost(struct net_device
*dev
)
38 struct ethtool_cmd ecmd
= { ETHTOOL_GSET
};
43 strncpy(ifr
.ifr_name
, dev
->name
, IFNAMSIZ
);
44 ifr
.ifr_data
= (void __user
*) &ecmd
;
48 err
= dev_ethtool(&ifr
);
64 /* Old silly heuristics based on name */
65 if (!strncmp(dev
->name
, "lec", 3))
68 if (!strncmp(dev
->name
, "plip", 4))
71 return 100; /* assume old 10Mbps */
76 * Check for port carrier transistions.
77 * Called from work queue to allow for calling functions that
78 * might sleep (such as speed check), and to debounce.
80 static void port_carrier_check(void *arg
)
82 struct net_device
*dev
= arg
;
83 struct net_bridge_port
*p
;
90 if (netif_carrier_ok(p
->dev
)) {
91 u32 cost
= port_cost(p
->dev
);
93 spin_lock_bh(&p
->br
->lock
);
94 if (p
->state
== BR_STATE_DISABLED
) {
96 br_stp_enable_port(p
);
98 spin_unlock_bh(&p
->br
->lock
);
100 spin_lock_bh(&p
->br
->lock
);
101 if (p
->state
!= BR_STATE_DISABLED
)
102 br_stp_disable_port(p
);
103 spin_unlock_bh(&p
->br
->lock
);
109 static void release_nbp(struct kobject
*kobj
)
111 struct net_bridge_port
*p
112 = container_of(kobj
, struct net_bridge_port
, kobj
);
116 static struct kobj_type brport_ktype
= {
118 .sysfs_ops
= &brport_sysfs_ops
,
120 .release
= release_nbp
,
123 static void destroy_nbp(struct net_bridge_port
*p
)
125 struct net_device
*dev
= p
->dev
;
131 kobject_put(&p
->kobj
);
134 static void destroy_nbp_rcu(struct rcu_head
*head
)
136 struct net_bridge_port
*p
=
137 container_of(head
, struct net_bridge_port
, rcu
);
141 /* Delete port(interface) from bridge is done in two steps.
142 * via RCU. First step, marks device as down. That deletes
143 * all the timers and stops new packets from flowing through.
145 * Final cleanup doesn't occur until after all CPU's finished
146 * processing packets.
148 * Protected from multiple admin operations by RTNL mutex
150 static void del_nbp(struct net_bridge_port
*p
)
152 struct net_bridge
*br
= p
->br
;
153 struct net_device
*dev
= p
->dev
;
155 sysfs_remove_link(&br
->ifobj
, dev
->name
);
157 dev_set_promiscuity(dev
, -1);
159 cancel_delayed_work(&p
->carrier_check
);
161 spin_lock_bh(&br
->lock
);
162 br_stp_disable_port(p
);
163 spin_unlock_bh(&br
->lock
);
165 br_fdb_delete_by_port(br
, p
);
167 list_del_rcu(&p
->list
);
169 rcu_assign_pointer(dev
->br_port
, NULL
);
171 kobject_del(&p
->kobj
);
173 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
176 /* called with RTNL */
177 static void del_br(struct net_bridge
*br
)
179 struct net_bridge_port
*p
, *n
;
181 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
185 del_timer_sync(&br
->gc_timer
);
187 br_sysfs_delbr(br
->dev
);
188 unregister_netdevice(br
->dev
);
191 static struct net_device
*new_bridge_dev(const char *name
)
193 struct net_bridge
*br
;
194 struct net_device
*dev
;
196 dev
= alloc_netdev(sizeof(struct net_bridge
), name
,
202 br
= netdev_priv(dev
);
205 spin_lock_init(&br
->lock
);
206 INIT_LIST_HEAD(&br
->port_list
);
207 spin_lock_init(&br
->hash_lock
);
209 br
->bridge_id
.prio
[0] = 0x80;
210 br
->bridge_id
.prio
[1] = 0x00;
211 memset(br
->bridge_id
.addr
, 0, ETH_ALEN
);
213 br
->feature_mask
= dev
->features
;
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
;
224 INIT_LIST_HEAD(&br
->age_list
);
226 br_stp_timer_init(br
);
231 /* find an available port number */
232 static int find_portno(struct net_bridge
*br
)
235 struct net_bridge_port
*p
;
236 unsigned long *inuse
;
238 inuse
= kmalloc(BITS_TO_LONGS(BR_MAX_PORTS
)*sizeof(unsigned long),
243 memset(inuse
, 0, BITS_TO_LONGS(BR_MAX_PORTS
)*sizeof(unsigned long));
244 set_bit(0, inuse
); /* zero is reserved */
245 list_for_each_entry(p
, &br
->port_list
, list
) {
246 set_bit(p
->port_no
, inuse
);
248 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
251 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
254 /* called with RTNL but without bridge lock */
255 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
256 struct net_device
*dev
)
259 struct net_bridge_port
*p
;
261 index
= find_portno(br
);
263 return ERR_PTR(index
);
265 p
= kmalloc(sizeof(*p
), GFP_KERNEL
);
267 return ERR_PTR(-ENOMEM
);
269 memset(p
, 0, sizeof(*p
));
273 p
->path_cost
= port_cost(dev
);
274 p
->priority
= 0x8000 >> BR_PORT_BITS
;
277 p
->state
= BR_STATE_DISABLED
;
278 INIT_WORK(&p
->carrier_check
, port_carrier_check
, dev
);
279 kobject_init(&p
->kobj
);
281 kobject_set_name(&p
->kobj
, SYSFS_BRIDGE_PORT_ATTR
);
282 p
->kobj
.ktype
= &brport_ktype
;
283 p
->kobj
.parent
= &(dev
->class_dev
.kobj
);
289 int br_add_bridge(const char *name
)
291 struct net_device
*dev
;
294 dev
= new_bridge_dev(name
);
299 if (strchr(dev
->name
, '%')) {
300 ret
= dev_alloc_name(dev
, dev
->name
);
305 ret
= register_netdevice(dev
);
309 /* network device kobject is not setup until
310 * after rtnl_unlock does it's hotplug magic.
311 * so hold reference to avoid race.
316 ret
= br_sysfs_addbr(dev
);
320 unregister_netdev(dev
);
331 int br_del_bridge(const char *name
)
333 struct net_device
*dev
;
337 dev
= __dev_get_by_name(name
);
339 ret
= -ENXIO
; /* Could not find device */
341 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
342 /* Attempt to delete non bridge device! */
346 else if (dev
->flags
& IFF_UP
) {
347 /* Not shutdown yet. */
352 del_br(netdev_priv(dev
));
358 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
359 int br_min_mtu(const struct net_bridge
*br
)
361 const struct net_bridge_port
*p
;
366 if (list_empty(&br
->port_list
))
369 list_for_each_entry(p
, &br
->port_list
, list
) {
370 if (!mtu
|| p
->dev
->mtu
< mtu
)
378 * Recomputes features using slave's features
380 void br_features_recompute(struct net_bridge
*br
)
382 struct net_bridge_port
*p
;
383 unsigned long features
, checksum
;
385 features
= br
->feature_mask
&~ NETIF_F_IP_CSUM
;
386 checksum
= br
->feature_mask
& NETIF_F_IP_CSUM
;
388 list_for_each_entry(p
, &br
->port_list
, list
) {
389 if (!(p
->dev
->features
390 & (NETIF_F_IP_CSUM
|NETIF_F_NO_CSUM
|NETIF_F_HW_CSUM
)))
392 features
&= p
->dev
->features
;
395 br
->dev
->features
= features
| checksum
| NETIF_F_LLTX
;
398 /* called with RTNL */
399 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
401 struct net_bridge_port
*p
;
404 if (dev
->flags
& IFF_LOOPBACK
|| dev
->type
!= ARPHRD_ETHER
)
407 if (dev
->hard_start_xmit
== br_dev_xmit
)
410 if (dev
->br_port
!= NULL
)
413 p
= new_nbp(br
, dev
);
417 err
= kobject_add(&p
->kobj
);
421 err
= br_fdb_insert(br
, p
, dev
->dev_addr
);
425 err
= br_sysfs_addif(p
);
429 rcu_assign_pointer(dev
->br_port
, p
);
430 dev_set_promiscuity(dev
, 1);
432 list_add_rcu(&p
->list
, &br
->port_list
);
434 spin_lock_bh(&br
->lock
);
435 br_stp_recalculate_bridge_id(br
);
436 br_features_recompute(br
);
437 schedule_delayed_work(&p
->carrier_check
, BR_PORT_DEBOUNCE
);
438 spin_unlock_bh(&br
->lock
);
440 dev_set_mtu(br
->dev
, br_min_mtu(br
));
441 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
445 br_fdb_delete_by_port(br
, p
);
447 kobject_del(&p
->kobj
);
449 kobject_put(&p
->kobj
);
453 /* called with RTNL */
454 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
456 struct net_bridge_port
*p
= dev
->br_port
;
458 if (!p
|| p
->br
!= br
)
463 spin_lock_bh(&br
->lock
);
464 br_stp_recalculate_bridge_id(br
);
465 br_features_recompute(br
);
466 spin_unlock_bh(&br
->lock
);
471 void __exit
br_cleanup_bridges(void)
473 struct net_device
*dev
, *nxt
;
476 for (dev
= dev_base
; dev
; dev
= nxt
) {
478 if (dev
->priv_flags
& IFF_EBRIDGE
)