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_bridge_port
*p
= arg
;
85 if (netif_carrier_ok(p
->dev
)) {
86 u32 cost
= port_cost(p
->dev
);
88 spin_lock_bh(&p
->br
->lock
);
89 if (p
->state
== BR_STATE_DISABLED
) {
91 br_stp_enable_port(p
);
93 spin_unlock_bh(&p
->br
->lock
);
95 spin_lock_bh(&p
->br
->lock
);
96 if (p
->state
!= BR_STATE_DISABLED
)
97 br_stp_disable_port(p
);
98 spin_unlock_bh(&p
->br
->lock
);
103 static void destroy_nbp(struct net_bridge_port
*p
)
105 struct net_device
*dev
= p
->dev
;
115 static void destroy_nbp_rcu(struct rcu_head
*head
)
117 struct net_bridge_port
*p
=
118 container_of(head
, struct net_bridge_port
, rcu
);
122 /* Delete port(interface) from bridge is done in two steps.
123 * via RCU. First step, marks device as down. That deletes
124 * all the timers and stops new packets from flowing through.
126 * Final cleanup doesn't occur until after all CPU's finished
127 * processing packets.
129 * Protected from multiple admin operations by RTNL mutex
131 static void del_nbp(struct net_bridge_port
*p
)
133 struct net_bridge
*br
= p
->br
;
134 struct net_device
*dev
= p
->dev
;
136 /* Race between RTNL notify and RCU callback */
140 dev_set_promiscuity(dev
, -1);
142 cancel_delayed_work(&p
->carrier_check
);
143 flush_scheduled_work();
145 spin_lock_bh(&br
->lock
);
146 br_stp_disable_port(p
);
148 spin_unlock_bh(&br
->lock
);
150 br_fdb_delete_by_port(br
, p
);
152 list_del_rcu(&p
->list
);
154 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
157 /* called with RTNL */
158 static void del_br(struct net_bridge
*br
)
160 struct net_bridge_port
*p
, *n
;
162 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
163 br_sysfs_removeif(p
);
167 del_timer_sync(&br
->gc_timer
);
169 br_sysfs_delbr(br
->dev
);
170 unregister_netdevice(br
->dev
);
173 static struct net_device
*new_bridge_dev(const char *name
)
175 struct net_bridge
*br
;
176 struct net_device
*dev
;
178 dev
= alloc_netdev(sizeof(struct net_bridge
), name
,
184 br
= netdev_priv(dev
);
187 spin_lock_init(&br
->lock
);
188 INIT_LIST_HEAD(&br
->port_list
);
189 spin_lock_init(&br
->hash_lock
);
191 br
->bridge_id
.prio
[0] = 0x80;
192 br
->bridge_id
.prio
[1] = 0x00;
193 memset(br
->bridge_id
.addr
, 0, ETH_ALEN
);
195 br
->feature_mask
= dev
->features
;
197 br
->designated_root
= br
->bridge_id
;
198 br
->root_path_cost
= 0;
200 br
->bridge_max_age
= br
->max_age
= 20 * HZ
;
201 br
->bridge_hello_time
= br
->hello_time
= 2 * HZ
;
202 br
->bridge_forward_delay
= br
->forward_delay
= 15 * HZ
;
203 br
->topology_change
= 0;
204 br
->topology_change_detected
= 0;
205 br
->ageing_time
= 300 * HZ
;
206 INIT_LIST_HEAD(&br
->age_list
);
208 br_stp_timer_init(br
);
213 /* find an available port number */
214 static int find_portno(struct net_bridge
*br
)
217 struct net_bridge_port
*p
;
218 unsigned long *inuse
;
220 inuse
= kmalloc(BITS_TO_LONGS(BR_MAX_PORTS
)*sizeof(unsigned long),
225 memset(inuse
, 0, BITS_TO_LONGS(BR_MAX_PORTS
)*sizeof(unsigned long));
226 set_bit(0, inuse
); /* zero is reserved */
227 list_for_each_entry(p
, &br
->port_list
, list
) {
228 set_bit(p
->port_no
, inuse
);
230 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
233 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
236 /* called with RTNL but without bridge lock */
237 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
238 struct net_device
*dev
)
241 struct net_bridge_port
*p
;
243 index
= find_portno(br
);
245 return ERR_PTR(index
);
247 p
= kmalloc(sizeof(*p
), GFP_KERNEL
);
249 return ERR_PTR(-ENOMEM
);
251 memset(p
, 0, sizeof(*p
));
255 p
->path_cost
= port_cost(dev
);
256 p
->priority
= 0x8000 >> BR_PORT_BITS
;
260 p
->state
= BR_STATE_DISABLED
;
261 INIT_WORK(&p
->carrier_check
, port_carrier_check
, p
);
262 kobject_init(&p
->kobj
);
267 int br_add_bridge(const char *name
)
269 struct net_device
*dev
;
272 dev
= new_bridge_dev(name
);
277 if (strchr(dev
->name
, '%')) {
278 ret
= dev_alloc_name(dev
, dev
->name
);
283 ret
= register_netdevice(dev
);
287 /* network device kobject is not setup until
288 * after rtnl_unlock does it's hotplug magic.
289 * so hold reference to avoid race.
294 ret
= br_sysfs_addbr(dev
);
298 unregister_netdev(dev
);
309 int br_del_bridge(const char *name
)
311 struct net_device
*dev
;
315 dev
= __dev_get_by_name(name
);
317 ret
= -ENXIO
; /* Could not find device */
319 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
320 /* Attempt to delete non bridge device! */
324 else if (dev
->flags
& IFF_UP
) {
325 /* Not shutdown yet. */
330 del_br(netdev_priv(dev
));
336 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
337 int br_min_mtu(const struct net_bridge
*br
)
339 const struct net_bridge_port
*p
;
344 if (list_empty(&br
->port_list
))
347 list_for_each_entry(p
, &br
->port_list
, list
) {
348 if (!mtu
|| p
->dev
->mtu
< mtu
)
356 * Recomputes features using slave's features
358 void br_features_recompute(struct net_bridge
*br
)
360 struct net_bridge_port
*p
;
361 unsigned long features
, checksum
;
363 features
= br
->feature_mask
&~ NETIF_F_IP_CSUM
;
364 checksum
= br
->feature_mask
& NETIF_F_IP_CSUM
;
366 list_for_each_entry(p
, &br
->port_list
, list
) {
367 if (!(p
->dev
->features
368 & (NETIF_F_IP_CSUM
|NETIF_F_NO_CSUM
|NETIF_F_HW_CSUM
)))
370 features
&= p
->dev
->features
;
373 br
->dev
->features
= features
| checksum
| NETIF_F_LLTX
;
376 /* called with RTNL */
377 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
379 struct net_bridge_port
*p
;
382 if (dev
->flags
& IFF_LOOPBACK
|| dev
->type
!= ARPHRD_ETHER
)
385 if (dev
->hard_start_xmit
== br_dev_xmit
)
388 if (dev
->br_port
!= NULL
)
391 if (IS_ERR(p
= new_nbp(br
, dev
)))
394 if ((err
= br_fdb_insert(br
, p
, dev
->dev_addr
)))
397 else if ((err
= br_sysfs_addif(p
)))
400 dev_set_promiscuity(dev
, 1);
402 list_add_rcu(&p
->list
, &br
->port_list
);
404 spin_lock_bh(&br
->lock
);
405 br_stp_recalculate_bridge_id(br
);
406 br_features_recompute(br
);
407 if ((br
->dev
->flags
& IFF_UP
)
408 && (dev
->flags
& IFF_UP
) && netif_carrier_ok(dev
))
409 br_stp_enable_port(p
);
410 spin_unlock_bh(&br
->lock
);
412 dev_set_mtu(br
->dev
, br_min_mtu(br
));
418 /* called with RTNL */
419 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
421 struct net_bridge_port
*p
= dev
->br_port
;
423 if (!p
|| p
->br
!= br
)
426 br_sysfs_removeif(p
);
429 spin_lock_bh(&br
->lock
);
430 br_stp_recalculate_bridge_id(br
);
431 br_features_recompute(br
);
432 spin_unlock_bh(&br
->lock
);
437 void __exit
br_cleanup_bridges(void)
439 struct net_device
*dev
, *nxt
;
442 for (dev
= dev_base
; dev
; dev
= nxt
) {
444 if (dev
->priv_flags
& IFF_EBRIDGE
)