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/netpoll.h>
17 #include <linux/ethtool.h>
18 #include <linux/if_arp.h>
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/if_ether.h>
23 #include <linux/slab.h>
26 #include "br_private.h"
29 * Determine initial path cost based on speed.
30 * using recommendations from 802.1d standard
32 * Since driver might sleep need to not be holding any locks.
34 static int port_cost(struct net_device
*dev
)
36 if (dev
->ethtool_ops
&& dev
->ethtool_ops
->get_settings
) {
37 struct ethtool_cmd ecmd
= { .cmd
= ETHTOOL_GSET
, };
39 if (!dev_ethtool_get_settings(dev
, &ecmd
)) {
40 switch (ethtool_cmd_speed(&ecmd
)) {
53 /* Old silly heuristics based on name */
54 if (!strncmp(dev
->name
, "lec", 3))
57 if (!strncmp(dev
->name
, "plip", 4))
60 return 100; /* assume old 10Mbps */
64 /* Check for port carrier transistions. */
65 void br_port_carrier_check(struct net_bridge_port
*p
)
67 struct net_device
*dev
= p
->dev
;
68 struct net_bridge
*br
= p
->br
;
70 if (netif_running(dev
) && netif_carrier_ok(dev
))
71 p
->path_cost
= port_cost(dev
);
73 if (!netif_running(br
->dev
))
76 spin_lock_bh(&br
->lock
);
77 if (netif_running(dev
) && netif_carrier_ok(dev
)) {
78 if (p
->state
== BR_STATE_DISABLED
)
79 br_stp_enable_port(p
);
81 if (p
->state
!= BR_STATE_DISABLED
)
82 br_stp_disable_port(p
);
84 spin_unlock_bh(&br
->lock
);
87 static void release_nbp(struct kobject
*kobj
)
89 struct net_bridge_port
*p
90 = container_of(kobj
, struct net_bridge_port
, kobj
);
94 static struct kobj_type brport_ktype
= {
96 .sysfs_ops
= &brport_sysfs_ops
,
98 .release
= release_nbp
,
101 static void destroy_nbp(struct net_bridge_port
*p
)
103 struct net_device
*dev
= p
->dev
;
109 kobject_put(&p
->kobj
);
112 static void destroy_nbp_rcu(struct rcu_head
*head
)
114 struct net_bridge_port
*p
=
115 container_of(head
, struct net_bridge_port
, rcu
);
119 /* Delete port(interface) from bridge is done in two steps.
120 * via RCU. First step, marks device as down. That deletes
121 * all the timers and stops new packets from flowing through.
123 * Final cleanup doesn't occur until after all CPU's finished
124 * processing packets.
126 * Protected from multiple admin operations by RTNL mutex
128 static void del_nbp(struct net_bridge_port
*p
)
130 struct net_bridge
*br
= p
->br
;
131 struct net_device
*dev
= p
->dev
;
133 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
135 dev_set_promiscuity(dev
, -1);
137 spin_lock_bh(&br
->lock
);
138 br_stp_disable_port(p
);
139 spin_unlock_bh(&br
->lock
);
141 br_ifinfo_notify(RTM_DELLINK
, p
);
143 br_fdb_delete_by_port(br
, p
, 1);
145 list_del_rcu(&p
->list
);
147 dev
->priv_flags
&= ~IFF_BRIDGE_PORT
;
149 netdev_rx_handler_unregister(dev
);
151 netdev_set_master(dev
, NULL
);
153 br_multicast_del_port(p
);
155 kobject_uevent(&p
->kobj
, KOBJ_REMOVE
);
156 kobject_del(&p
->kobj
);
158 br_netpoll_disable(p
);
160 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
163 /* called with RTNL */
164 static void del_br(struct net_bridge
*br
, struct list_head
*head
)
166 struct net_bridge_port
*p
, *n
;
168 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
172 del_timer_sync(&br
->gc_timer
);
174 br_sysfs_delbr(br
->dev
);
175 unregister_netdevice_queue(br
->dev
, head
);
178 /* find an available port number */
179 static int find_portno(struct net_bridge
*br
)
182 struct net_bridge_port
*p
;
183 unsigned long *inuse
;
185 inuse
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
190 set_bit(0, inuse
); /* zero is reserved */
191 list_for_each_entry(p
, &br
->port_list
, list
) {
192 set_bit(p
->port_no
, inuse
);
194 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
197 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
200 /* called with RTNL but without bridge lock */
201 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
202 struct net_device
*dev
)
205 struct net_bridge_port
*p
;
207 index
= find_portno(br
);
209 return ERR_PTR(index
);
211 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
213 return ERR_PTR(-ENOMEM
);
218 p
->path_cost
= port_cost(dev
);
219 p
->priority
= 0x8000 >> BR_PORT_BITS
;
223 p
->state
= BR_STATE_DISABLED
;
224 br_stp_port_timer_init(p
);
225 br_multicast_add_port(p
);
230 int br_add_bridge(struct net
*net
, const char *name
)
232 struct net_device
*dev
;
234 dev
= alloc_netdev(sizeof(struct net_bridge
), name
,
240 dev_net_set(dev
, net
);
242 return register_netdev(dev
);
245 int br_del_bridge(struct net
*net
, const char *name
)
247 struct net_device
*dev
;
251 dev
= __dev_get_by_name(net
, name
);
253 ret
= -ENXIO
; /* Could not find device */
255 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
256 /* Attempt to delete non bridge device! */
260 else if (dev
->flags
& IFF_UP
) {
261 /* Not shutdown yet. */
266 del_br(netdev_priv(dev
), NULL
);
272 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
273 int br_min_mtu(const struct net_bridge
*br
)
275 const struct net_bridge_port
*p
;
280 if (list_empty(&br
->port_list
))
283 list_for_each_entry(p
, &br
->port_list
, list
) {
284 if (!mtu
|| p
->dev
->mtu
< mtu
)
292 * Recomputes features using slave's features
294 u32
br_features_recompute(struct net_bridge
*br
, u32 features
)
296 struct net_bridge_port
*p
;
299 if (list_empty(&br
->port_list
))
303 features
&= ~NETIF_F_ONE_FOR_ALL
;
305 list_for_each_entry(p
, &br
->port_list
, list
) {
306 features
= netdev_increment_features(features
,
307 p
->dev
->features
, mask
);
313 /* called with RTNL */
314 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
316 struct net_bridge_port
*p
;
320 /* Don't allow bridging non-ethernet like devices */
321 if ((dev
->flags
& IFF_LOOPBACK
) ||
322 dev
->type
!= ARPHRD_ETHER
|| dev
->addr_len
!= ETH_ALEN
)
325 /* No bridging of bridges */
326 if (dev
->netdev_ops
->ndo_start_xmit
== br_dev_xmit
)
329 /* Device is already being bridged */
330 if (br_port_exists(dev
))
333 /* No bridging devices that dislike that (e.g. wireless) */
334 if (dev
->priv_flags
& IFF_DONT_BRIDGE
)
337 p
= new_nbp(br
, dev
);
341 err
= dev_set_promiscuity(dev
, 1);
345 err
= kobject_init_and_add(&p
->kobj
, &brport_ktype
, &(dev
->dev
.kobj
),
346 SYSFS_BRIDGE_PORT_ATTR
);
350 err
= br_fdb_insert(br
, p
, dev
->dev_addr
);
354 err
= br_sysfs_addif(p
);
358 if (br_netpoll_info(br
) && ((err
= br_netpoll_enable(p
))))
361 err
= netdev_set_master(dev
, br
->dev
);
365 err
= netdev_rx_handler_register(dev
, br_handle_frame
, p
);
369 dev
->priv_flags
|= IFF_BRIDGE_PORT
;
371 dev_disable_lro(dev
);
373 list_add_rcu(&p
->list
, &br
->port_list
);
375 netdev_update_features(br
->dev
);
377 spin_lock_bh(&br
->lock
);
378 changed_addr
= br_stp_recalculate_bridge_id(br
);
380 if ((dev
->flags
& IFF_UP
) && netif_carrier_ok(dev
) &&
381 (br
->dev
->flags
& IFF_UP
))
382 br_stp_enable_port(p
);
383 spin_unlock_bh(&br
->lock
);
385 br_ifinfo_notify(RTM_NEWLINK
, p
);
388 call_netdevice_notifiers(NETDEV_CHANGEADDR
, dev
);
390 dev_set_mtu(br
->dev
, br_min_mtu(br
));
392 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
397 netdev_set_master(dev
, NULL
);
399 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
401 br_fdb_delete_by_port(br
, p
, 1);
403 kobject_put(&p
->kobj
);
404 p
= NULL
; /* kobject_put frees */
406 dev_set_promiscuity(dev
, -1);
413 /* called with RTNL */
414 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
416 struct net_bridge_port
*p
;
418 p
= br_port_get_rtnl(dev
);
419 if (!p
|| p
->br
!= br
)
424 spin_lock_bh(&br
->lock
);
425 br_stp_recalculate_bridge_id(br
);
426 spin_unlock_bh(&br
->lock
);
428 netdev_update_features(br
->dev
);
433 void __net_exit
br_net_exit(struct net
*net
)
435 struct net_device
*dev
;
439 for_each_netdev(net
, dev
)
440 if (dev
->priv_flags
& IFF_EBRIDGE
)
441 del_br(netdev_priv(dev
), &list
);
443 unregister_netdevice_many(&list
);
This page took 0.048485 seconds and 5 git commands to generate.