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/ethtool.h>
17 #include <linux/if_arp.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/if_ether.h>
22 #include <linux/slab.h>
25 #include "br_private.h"
28 * Determine initial path cost based on speed.
29 * using recommendations from 802.1d standard
31 * Since driver might sleep need to not be holding any locks.
33 static int port_cost(struct net_device
*dev
)
35 if (dev
->ethtool_ops
&& dev
->ethtool_ops
->get_settings
) {
36 struct ethtool_cmd ecmd
= { .cmd
= ETHTOOL_GSET
, };
38 if (!dev
->ethtool_ops
->get_settings(dev
, &ecmd
)) {
52 /* Old silly heuristics based on name */
53 if (!strncmp(dev
->name
, "lec", 3))
56 if (!strncmp(dev
->name
, "plip", 4))
59 return 100; /* assume old 10Mbps */
64 * Check for port carrier transistions.
65 * Called from work queue to allow for calling functions that
66 * might sleep (such as speed check), and to debounce.
68 void br_port_carrier_check(struct net_bridge_port
*p
)
70 struct net_device
*dev
= p
->dev
;
71 struct net_bridge
*br
= p
->br
;
73 if (netif_carrier_ok(dev
))
74 p
->path_cost
= port_cost(dev
);
76 if (netif_running(br
->dev
)) {
77 spin_lock_bh(&br
->lock
);
78 if (netif_carrier_ok(dev
)) {
79 if (p
->state
== BR_STATE_DISABLED
)
80 br_stp_enable_port(p
);
82 if (p
->state
!= BR_STATE_DISABLED
)
83 br_stp_disable_port(p
);
85 spin_unlock_bh(&br
->lock
);
89 static void release_nbp(struct kobject
*kobj
)
91 struct net_bridge_port
*p
92 = container_of(kobj
, struct net_bridge_port
, kobj
);
96 static struct kobj_type brport_ktype
= {
98 .sysfs_ops
= &brport_sysfs_ops
,
100 .release
= release_nbp
,
103 static void destroy_nbp(struct net_bridge_port
*p
)
105 struct net_device
*dev
= p
->dev
;
111 kobject_put(&p
->kobj
);
114 static void destroy_nbp_rcu(struct rcu_head
*head
)
116 struct net_bridge_port
*p
=
117 container_of(head
, struct net_bridge_port
, rcu
);
121 /* Delete port(interface) from bridge is done in two steps.
122 * via RCU. First step, marks device as down. That deletes
123 * all the timers and stops new packets from flowing through.
125 * Final cleanup doesn't occur until after all CPU's finished
126 * processing packets.
128 * Protected from multiple admin operations by RTNL mutex
130 static void del_nbp(struct net_bridge_port
*p
)
132 struct net_bridge
*br
= p
->br
;
133 struct net_device
*dev
= p
->dev
;
135 sysfs_remove_link(br
->ifobj
, dev
->name
);
137 dev_set_promiscuity(dev
, -1);
139 spin_lock_bh(&br
->lock
);
140 br_stp_disable_port(p
);
141 spin_unlock_bh(&br
->lock
);
143 br_ifinfo_notify(RTM_DELLINK
, p
);
145 br_fdb_delete_by_port(br
, p
, 1);
147 list_del_rcu(&p
->list
);
149 rcu_assign_pointer(dev
->br_port
, NULL
);
151 br_multicast_del_port(p
);
153 kobject_uevent(&p
->kobj
, KOBJ_REMOVE
);
154 kobject_del(&p
->kobj
);
156 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
159 /* called with RTNL */
160 static void del_br(struct net_bridge
*br
, struct list_head
*head
)
162 struct net_bridge_port
*p
, *n
;
164 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
168 del_timer_sync(&br
->gc_timer
);
170 br_sysfs_delbr(br
->dev
);
171 unregister_netdevice_queue(br
->dev
, head
);
174 static struct net_device
*new_bridge_dev(struct net
*net
, const char *name
)
176 struct net_bridge
*br
;
177 struct net_device
*dev
;
179 dev
= alloc_netdev(sizeof(struct net_bridge
), name
,
184 dev_net_set(dev
, net
);
186 br
= netdev_priv(dev
);
189 spin_lock_init(&br
->lock
);
190 INIT_LIST_HEAD(&br
->port_list
);
191 spin_lock_init(&br
->hash_lock
);
193 br
->bridge_id
.prio
[0] = 0x80;
194 br
->bridge_id
.prio
[1] = 0x00;
196 memcpy(br
->group_addr
, br_group_address
, ETH_ALEN
);
198 br
->feature_mask
= dev
->features
;
199 br
->stp_enabled
= BR_NO_STP
;
200 br
->designated_root
= br
->bridge_id
;
201 br
->root_path_cost
= 0;
203 br
->bridge_max_age
= br
->max_age
= 20 * HZ
;
204 br
->bridge_hello_time
= br
->hello_time
= 2 * HZ
;
205 br
->bridge_forward_delay
= br
->forward_delay
= 15 * HZ
;
206 br
->topology_change
= 0;
207 br
->topology_change_detected
= 0;
208 br
->ageing_time
= 300 * HZ
;
210 br_netfilter_rtable_init(br
);
212 br_stp_timer_init(br
);
213 br_multicast_init(br
);
218 /* find an available port number */
219 static int find_portno(struct net_bridge
*br
)
222 struct net_bridge_port
*p
;
223 unsigned long *inuse
;
225 inuse
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
230 set_bit(0, inuse
); /* zero is reserved */
231 list_for_each_entry(p
, &br
->port_list
, list
) {
232 set_bit(p
->port_no
, inuse
);
234 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
237 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
240 /* called with RTNL but without bridge lock */
241 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
242 struct net_device
*dev
)
245 struct net_bridge_port
*p
;
247 index
= find_portno(br
);
249 return ERR_PTR(index
);
251 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
253 return ERR_PTR(-ENOMEM
);
258 p
->path_cost
= port_cost(dev
);
259 p
->priority
= 0x8000 >> BR_PORT_BITS
;
263 p
->state
= BR_STATE_DISABLED
;
264 br_stp_port_timer_init(p
);
265 br_multicast_add_port(p
);
270 static struct device_type br_type
= {
274 int br_add_bridge(struct net
*net
, const char *name
)
276 struct net_device
*dev
;
279 dev
= new_bridge_dev(net
, name
);
284 if (strchr(dev
->name
, '%')) {
285 ret
= dev_alloc_name(dev
, dev
->name
);
290 SET_NETDEV_DEVTYPE(dev
, &br_type
);
292 ret
= register_netdevice(dev
);
296 ret
= br_sysfs_addbr(dev
);
298 unregister_netdevice(dev
);
308 int br_del_bridge(struct net
*net
, const char *name
)
310 struct net_device
*dev
;
314 dev
= __dev_get_by_name(net
, name
);
316 ret
= -ENXIO
; /* Could not find device */
318 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
319 /* Attempt to delete non bridge device! */
323 else if (dev
->flags
& IFF_UP
) {
324 /* Not shutdown yet. */
329 del_br(netdev_priv(dev
), NULL
);
335 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
336 int br_min_mtu(const struct net_bridge
*br
)
338 const struct net_bridge_port
*p
;
343 if (list_empty(&br
->port_list
))
346 list_for_each_entry(p
, &br
->port_list
, list
) {
347 if (!mtu
|| p
->dev
->mtu
< mtu
)
355 * Recomputes features using slave's features
357 void br_features_recompute(struct net_bridge
*br
)
359 struct net_bridge_port
*p
;
360 unsigned long features
, mask
;
362 features
= mask
= br
->feature_mask
;
363 if (list_empty(&br
->port_list
))
366 features
&= ~NETIF_F_ONE_FOR_ALL
;
368 list_for_each_entry(p
, &br
->port_list
, list
) {
369 features
= netdev_increment_features(features
,
370 p
->dev
->features
, mask
);
374 br
->dev
->features
= netdev_fix_features(features
, NULL
);
377 /* called with RTNL */
378 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
380 struct net_bridge_port
*p
;
383 /* Don't allow bridging non-ethernet like devices */
384 if ((dev
->flags
& IFF_LOOPBACK
) ||
385 dev
->type
!= ARPHRD_ETHER
|| dev
->addr_len
!= ETH_ALEN
)
388 /* No bridging of bridges */
389 if (dev
->netdev_ops
->ndo_start_xmit
== br_dev_xmit
)
392 /* Device is already being bridged */
393 if (dev
->br_port
!= NULL
)
396 /* No bridging devices that dislike that (e.g. wireless) */
397 if (dev
->priv_flags
& IFF_DONT_BRIDGE
)
400 p
= new_nbp(br
, dev
);
404 err
= dev_set_promiscuity(dev
, 1);
408 err
= kobject_init_and_add(&p
->kobj
, &brport_ktype
, &(dev
->dev
.kobj
),
409 SYSFS_BRIDGE_PORT_ATTR
);
413 err
= br_fdb_insert(br
, p
, dev
->dev_addr
);
417 err
= br_sysfs_addif(p
);
421 rcu_assign_pointer(dev
->br_port
, p
);
422 dev_disable_lro(dev
);
424 list_add_rcu(&p
->list
, &br
->port_list
);
426 spin_lock_bh(&br
->lock
);
427 br_stp_recalculate_bridge_id(br
);
428 br_features_recompute(br
);
430 if ((dev
->flags
& IFF_UP
) && netif_carrier_ok(dev
) &&
431 (br
->dev
->flags
& IFF_UP
))
432 br_stp_enable_port(p
);
433 spin_unlock_bh(&br
->lock
);
435 br_ifinfo_notify(RTM_NEWLINK
, p
);
437 dev_set_mtu(br
->dev
, br_min_mtu(br
));
439 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
443 br_fdb_delete_by_port(br
, p
, 1);
445 kobject_put(&p
->kobj
);
446 p
= NULL
; /* kobject_put frees */
448 dev_set_promiscuity(dev
, -1);
455 /* called with RTNL */
456 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
458 struct net_bridge_port
*p
= dev
->br_port
;
460 if (!p
|| p
->br
!= br
)
465 spin_lock_bh(&br
->lock
);
466 br_stp_recalculate_bridge_id(br
);
467 br_features_recompute(br
);
468 spin_unlock_bh(&br
->lock
);
473 void __net_exit
br_net_exit(struct net
*net
)
475 struct net_device
*dev
;
479 for_each_netdev(net
, dev
)
480 if (dev
->priv_flags
& IFF_EBRIDGE
)
481 del_br(netdev_priv(dev
), &list
);
483 unregister_netdevice_many(&list
);