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(struct work_struct
*work
)
82 struct net_bridge_port
*p
;
83 struct net_device
*dev
;
84 struct net_bridge
*br
;
86 dev
= container_of(work
, struct net_bridge_port
,
87 carrier_check
.work
)->dev
;
96 if (netif_carrier_ok(dev
))
97 p
->path_cost
= port_cost(dev
);
99 if (br
->dev
->flags
& IFF_UP
) {
100 spin_lock_bh(&br
->lock
);
101 if (netif_carrier_ok(dev
)) {
102 if (p
->state
== BR_STATE_DISABLED
)
103 br_stp_enable_port(p
);
105 if (p
->state
!= BR_STATE_DISABLED
)
106 br_stp_disable_port(p
);
108 spin_unlock_bh(&br
->lock
);
114 static void release_nbp(struct kobject
*kobj
)
116 struct net_bridge_port
*p
117 = container_of(kobj
, struct net_bridge_port
, kobj
);
121 static struct kobj_type brport_ktype
= {
123 .sysfs_ops
= &brport_sysfs_ops
,
125 .release
= release_nbp
,
128 static void destroy_nbp(struct net_bridge_port
*p
)
130 struct net_device
*dev
= p
->dev
;
136 kobject_put(&p
->kobj
);
139 static void destroy_nbp_rcu(struct rcu_head
*head
)
141 struct net_bridge_port
*p
=
142 container_of(head
, struct net_bridge_port
, rcu
);
146 /* Delete port(interface) from bridge is done in two steps.
147 * via RCU. First step, marks device as down. That deletes
148 * all the timers and stops new packets from flowing through.
150 * Final cleanup doesn't occur until after all CPU's finished
151 * processing packets.
153 * Protected from multiple admin operations by RTNL mutex
155 static void del_nbp(struct net_bridge_port
*p
)
157 struct net_bridge
*br
= p
->br
;
158 struct net_device
*dev
= p
->dev
;
160 sysfs_remove_link(&br
->ifobj
, dev
->name
);
162 dev_set_promiscuity(dev
, -1);
164 cancel_delayed_work(&p
->carrier_check
);
166 spin_lock_bh(&br
->lock
);
167 br_stp_disable_port(p
);
168 spin_unlock_bh(&br
->lock
);
170 br_fdb_delete_by_port(br
, p
, 1);
172 list_del_rcu(&p
->list
);
174 rcu_assign_pointer(dev
->br_port
, NULL
);
176 kobject_uevent(&p
->kobj
, KOBJ_REMOVE
);
177 kobject_del(&p
->kobj
);
179 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
182 /* called with RTNL */
183 static void del_br(struct net_bridge
*br
)
185 struct net_bridge_port
*p
, *n
;
187 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
191 del_timer_sync(&br
->gc_timer
);
193 br_sysfs_delbr(br
->dev
);
194 unregister_netdevice(br
->dev
);
197 static struct net_device
*new_bridge_dev(const char *name
)
199 struct net_bridge
*br
;
200 struct net_device
*dev
;
202 dev
= alloc_netdev(sizeof(struct net_bridge
), name
,
208 br
= netdev_priv(dev
);
211 spin_lock_init(&br
->lock
);
212 INIT_LIST_HEAD(&br
->port_list
);
213 spin_lock_init(&br
->hash_lock
);
215 br
->bridge_id
.prio
[0] = 0x80;
216 br
->bridge_id
.prio
[1] = 0x00;
218 memcpy(br
->group_addr
, br_group_address
, ETH_ALEN
);
220 br
->feature_mask
= dev
->features
;
222 br
->designated_root
= br
->bridge_id
;
223 br
->root_path_cost
= 0;
225 br
->bridge_max_age
= br
->max_age
= 20 * HZ
;
226 br
->bridge_hello_time
= br
->hello_time
= 2 * HZ
;
227 br
->bridge_forward_delay
= br
->forward_delay
= 15 * HZ
;
228 br
->topology_change
= 0;
229 br
->topology_change_detected
= 0;
230 br
->ageing_time
= 300 * HZ
;
231 INIT_LIST_HEAD(&br
->age_list
);
233 br_stp_timer_init(br
);
238 /* find an available port number */
239 static int find_portno(struct net_bridge
*br
)
242 struct net_bridge_port
*p
;
243 unsigned long *inuse
;
245 inuse
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
250 set_bit(0, inuse
); /* zero is reserved */
251 list_for_each_entry(p
, &br
->port_list
, list
) {
252 set_bit(p
->port_no
, inuse
);
254 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
257 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
260 /* called with RTNL but without bridge lock */
261 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
262 struct net_device
*dev
)
265 struct net_bridge_port
*p
;
267 index
= find_portno(br
);
269 return ERR_PTR(index
);
271 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
273 return ERR_PTR(-ENOMEM
);
278 p
->path_cost
= port_cost(dev
);
279 p
->priority
= 0x8000 >> BR_PORT_BITS
;
282 p
->state
= BR_STATE_DISABLED
;
283 INIT_DELAYED_WORK_NAR(&p
->carrier_check
, port_carrier_check
);
284 br_stp_port_timer_init(p
);
286 kobject_init(&p
->kobj
);
287 kobject_set_name(&p
->kobj
, SYSFS_BRIDGE_PORT_ATTR
);
288 p
->kobj
.ktype
= &brport_ktype
;
289 p
->kobj
.parent
= &(dev
->class_dev
.kobj
);
295 int br_add_bridge(const char *name
)
297 struct net_device
*dev
;
300 dev
= new_bridge_dev(name
);
305 if (strchr(dev
->name
, '%')) {
306 ret
= dev_alloc_name(dev
, dev
->name
);
313 ret
= register_netdevice(dev
);
317 ret
= br_sysfs_addbr(dev
);
319 unregister_netdevice(dev
);
325 int br_del_bridge(const char *name
)
327 struct net_device
*dev
;
331 dev
= __dev_get_by_name(name
);
333 ret
= -ENXIO
; /* Could not find device */
335 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
336 /* Attempt to delete non bridge device! */
340 else if (dev
->flags
& IFF_UP
) {
341 /* Not shutdown yet. */
346 del_br(netdev_priv(dev
));
352 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
353 int br_min_mtu(const struct net_bridge
*br
)
355 const struct net_bridge_port
*p
;
360 if (list_empty(&br
->port_list
))
363 list_for_each_entry(p
, &br
->port_list
, list
) {
364 if (!mtu
|| p
->dev
->mtu
< mtu
)
372 * Recomputes features using slave's features
374 void br_features_recompute(struct net_bridge
*br
)
376 struct net_bridge_port
*p
;
377 unsigned long features
, checksum
;
379 checksum
= br
->feature_mask
& NETIF_F_ALL_CSUM
? NETIF_F_NO_CSUM
: 0;
380 features
= br
->feature_mask
& ~NETIF_F_ALL_CSUM
;
382 list_for_each_entry(p
, &br
->port_list
, list
) {
383 unsigned long feature
= p
->dev
->features
;
385 if (checksum
& NETIF_F_NO_CSUM
&& !(feature
& NETIF_F_NO_CSUM
))
386 checksum
^= NETIF_F_NO_CSUM
| NETIF_F_HW_CSUM
;
387 if (checksum
& NETIF_F_HW_CSUM
&& !(feature
& NETIF_F_HW_CSUM
))
388 checksum
^= NETIF_F_HW_CSUM
| NETIF_F_IP_CSUM
;
389 if (!(feature
& NETIF_F_IP_CSUM
))
392 if (feature
& NETIF_F_GSO
)
393 feature
|= NETIF_F_GSO_SOFTWARE
;
394 feature
|= NETIF_F_GSO
;
399 if (!(checksum
& NETIF_F_ALL_CSUM
))
400 features
&= ~NETIF_F_SG
;
401 if (!(features
& NETIF_F_SG
))
402 features
&= ~NETIF_F_GSO_MASK
;
404 br
->dev
->features
= features
| checksum
| NETIF_F_LLTX
|
408 /* called with RTNL */
409 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
411 struct net_bridge_port
*p
;
414 if (dev
->flags
& IFF_LOOPBACK
|| dev
->type
!= ARPHRD_ETHER
)
417 if (dev
->hard_start_xmit
== br_dev_xmit
)
420 if (dev
->br_port
!= NULL
)
423 p
= new_nbp(br
, dev
);
427 err
= kobject_add(&p
->kobj
);
431 err
= br_fdb_insert(br
, p
, dev
->dev_addr
);
435 err
= br_sysfs_addif(p
);
439 rcu_assign_pointer(dev
->br_port
, p
);
440 dev_set_promiscuity(dev
, 1);
442 list_add_rcu(&p
->list
, &br
->port_list
);
444 spin_lock_bh(&br
->lock
);
445 br_stp_recalculate_bridge_id(br
);
446 br_features_recompute(br
);
447 schedule_delayed_work(&p
->carrier_check
, BR_PORT_DEBOUNCE
);
448 spin_unlock_bh(&br
->lock
);
450 dev_set_mtu(br
->dev
, br_min_mtu(br
));
451 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
455 br_fdb_delete_by_port(br
, p
, 1);
457 kobject_del(&p
->kobj
);
459 kobject_put(&p
->kobj
);
463 /* called with RTNL */
464 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
466 struct net_bridge_port
*p
= dev
->br_port
;
468 if (!p
|| p
->br
!= br
)
473 spin_lock_bh(&br
->lock
);
474 br_stp_recalculate_bridge_id(br
);
475 br_features_recompute(br
);
476 spin_unlock_bh(&br
->lock
);
481 void __exit
br_cleanup_bridges(void)
483 struct net_device
*dev
, *nxt
;
486 for (dev
= dev_base
; dev
; dev
= nxt
) {
488 if (dev
->priv_flags
& IFF_EBRIDGE
)