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/etherdevice.h>
17 #include <linux/netpoll.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>
24 #include <linux/slab.h>
26 #include <linux/if_vlan.h>
28 #include "br_private.h"
31 * Determine initial path cost based on speed.
32 * using recommendations from 802.1d standard
34 * Since driver might sleep need to not be holding any locks.
36 static int port_cost(struct net_device *dev)
38 struct ethtool_cmd ecmd;
40 if (!__ethtool_get_settings(dev, &ecmd)) {
41 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 transitions. */
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 (!(p->flags & BR_ADMIN_COST) &&
71 netif_running(dev) && netif_oper_up(dev))
72 p->path_cost = port_cost(dev);
74 if (!netif_running(br->dev))
77 spin_lock_bh(&br->lock);
78 if (netif_running(dev) && netif_oper_up(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);
88 static void nbp_update_port_count(struct net_bridge *br)
90 struct net_bridge_port *p;
93 list_for_each_entry(p, &br->port_list, list) {
100 static void release_nbp(struct kobject *kobj)
102 struct net_bridge_port *p
103 = container_of(kobj, struct net_bridge_port, kobj);
107 static struct kobj_type brport_ktype = {
109 .sysfs_ops = &brport_sysfs_ops,
111 .release = release_nbp,
114 static void destroy_nbp(struct net_bridge_port *p)
116 struct net_device *dev = p->dev;
122 kobject_put(&p->kobj);
125 static void destroy_nbp_rcu(struct rcu_head *head)
127 struct net_bridge_port *p =
128 container_of(head, struct net_bridge_port, rcu);
132 /* Delete port(interface) from bridge is done in two steps.
133 * via RCU. First step, marks device as down. That deletes
134 * all the timers and stops new packets from flowing through.
136 * Final cleanup doesn't occur until after all CPU's finished
137 * processing packets.
139 * Protected from multiple admin operations by RTNL mutex
141 static void del_nbp(struct net_bridge_port *p)
143 struct net_bridge *br = p->br;
144 struct net_device *dev = p->dev;
146 sysfs_remove_link(br->ifobj, p->dev->name);
148 dev_set_promiscuity(dev, -1);
150 spin_lock_bh(&br->lock);
151 br_stp_disable_port(p);
152 spin_unlock_bh(&br->lock);
154 br_ifinfo_notify(RTM_DELLINK, p);
157 br_fdb_delete_by_port(br, p, 1);
159 list_del_rcu(&p->list);
161 nbp_update_port_count(br);
163 dev->priv_flags &= ~IFF_BRIDGE_PORT;
165 netdev_rx_handler_unregister(dev);
167 netdev_upper_dev_unlink(dev, br->dev);
169 br_multicast_del_port(p);
171 kobject_uevent(&p->kobj, KOBJ_REMOVE);
172 kobject_del(&p->kobj);
174 br_netpoll_disable(p);
176 call_rcu(&p->rcu, destroy_nbp_rcu);
179 /* Delete bridge device */
180 void br_dev_delete(struct net_device *dev, struct list_head *head)
182 struct net_bridge *br = netdev_priv(dev);
183 struct net_bridge_port *p, *n;
185 list_for_each_entry_safe(p, n, &br->port_list, list) {
189 br_fdb_delete_by_port(br, NULL, 1);
192 del_timer_sync(&br->gc_timer);
194 br_sysfs_delbr(br->dev);
195 unregister_netdevice_queue(br->dev, head);
198 /* find an available port number */
199 static int find_portno(struct net_bridge *br)
202 struct net_bridge_port *p;
203 unsigned long *inuse;
205 inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
210 set_bit(0, inuse); /* zero is reserved */
211 list_for_each_entry(p, &br->port_list, list) {
212 set_bit(p->port_no, inuse);
214 index = find_first_zero_bit(inuse, BR_MAX_PORTS);
217 return (index >= BR_MAX_PORTS) ? -EXFULL : index;
220 /* called with RTNL but without bridge lock */
221 static struct net_bridge_port *new_nbp(struct net_bridge *br,
222 struct net_device *dev)
225 struct net_bridge_port *p;
227 index = find_portno(br);
229 return ERR_PTR(index);
231 p = kzalloc(sizeof(*p), GFP_KERNEL);
233 return ERR_PTR(-ENOMEM);
238 p->path_cost = port_cost(dev);
239 p->priority = 0x8000 >> BR_PORT_BITS;
241 p->flags = BR_LEARNING | BR_FLOOD;
243 p->state = BR_STATE_DISABLED;
244 br_stp_port_timer_init(p);
245 br_multicast_add_port(p);
250 int br_add_bridge(struct net *net, const char *name)
252 struct net_device *dev;
255 dev = alloc_netdev(sizeof(struct net_bridge), name,
261 dev_net_set(dev, net);
262 dev->rtnl_link_ops = &br_link_ops;
264 res = register_netdev(dev);
270 int br_del_bridge(struct net *net, const char *name)
272 struct net_device *dev;
276 dev = __dev_get_by_name(net, name);
278 ret = -ENXIO; /* Could not find device */
280 else if (!(dev->priv_flags & IFF_EBRIDGE)) {
281 /* Attempt to delete non bridge device! */
285 else if (dev->flags & IFF_UP) {
286 /* Not shutdown yet. */
291 br_dev_delete(dev, NULL);
297 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
298 int br_min_mtu(const struct net_bridge *br)
300 const struct net_bridge_port *p;
305 if (list_empty(&br->port_list))
308 list_for_each_entry(p, &br->port_list, list) {
309 if (!mtu || p->dev->mtu < mtu)
317 * Recomputes features using slave's features
319 netdev_features_t br_features_recompute(struct net_bridge *br,
320 netdev_features_t features)
322 struct net_bridge_port *p;
323 netdev_features_t mask;
325 if (list_empty(&br->port_list))
329 features &= ~NETIF_F_ONE_FOR_ALL;
331 list_for_each_entry(p, &br->port_list, list) {
332 features = netdev_increment_features(features,
333 p->dev->features, mask);
339 /* called with RTNL */
340 int br_add_if(struct net_bridge *br, struct net_device *dev)
342 struct net_bridge_port *p;
346 /* Don't allow bridging non-ethernet like devices */
347 if ((dev->flags & IFF_LOOPBACK) ||
348 dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN ||
349 !is_valid_ether_addr(dev->dev_addr))
352 /* No bridging of bridges */
353 if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit)
356 /* Device is already being bridged */
357 if (br_port_exists(dev))
360 /* No bridging devices that dislike that (e.g. wireless) */
361 if (dev->priv_flags & IFF_DONT_BRIDGE)
364 p = new_nbp(br, dev);
368 call_netdevice_notifiers(NETDEV_JOIN, dev);
370 err = dev_set_promiscuity(dev, 1);
374 err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
375 SYSFS_BRIDGE_PORT_ATTR);
379 err = br_sysfs_addif(p);
383 err = br_netpoll_enable(p);
387 err = netdev_master_upper_dev_link(dev, br->dev);
391 err = netdev_rx_handler_register(dev, br_handle_frame, p);
395 dev->priv_flags |= IFF_BRIDGE_PORT;
397 dev_disable_lro(dev);
399 list_add_rcu(&p->list, &br->port_list);
401 nbp_update_port_count(br);
403 netdev_update_features(br->dev);
405 if (br->dev->needed_headroom < dev->needed_headroom)
406 br->dev->needed_headroom = dev->needed_headroom;
408 if (br_fdb_insert(br, p, dev->dev_addr, 0))
409 netdev_err(dev, "failed insert local address bridge forwarding table\n");
411 spin_lock_bh(&br->lock);
412 changed_addr = br_stp_recalculate_bridge_id(br);
414 if (netif_running(dev) && netif_oper_up(dev) &&
415 (br->dev->flags & IFF_UP))
416 br_stp_enable_port(p);
417 spin_unlock_bh(&br->lock);
419 br_ifinfo_notify(RTM_NEWLINK, p);
422 call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
424 dev_set_mtu(br->dev, br_min_mtu(br));
426 kobject_uevent(&p->kobj, KOBJ_ADD);
431 netdev_upper_dev_unlink(dev, br->dev);
433 br_netpoll_disable(p);
435 sysfs_remove_link(br->ifobj, p->dev->name);
437 kobject_put(&p->kobj);
438 p = NULL; /* kobject_put frees */
440 dev_set_promiscuity(dev, -1);
447 /* called with RTNL */
448 int br_del_if(struct net_bridge *br, struct net_device *dev)
450 struct net_bridge_port *p;
453 p = br_port_get_rtnl(dev);
454 if (!p || p->br != br)
457 /* Since more than one interface can be attached to a bridge,
458 * there still maybe an alternate path for netconsole to use;
459 * therefore there is no reason for a NETDEV_RELEASE event.
463 spin_lock_bh(&br->lock);
464 changed_addr = br_stp_recalculate_bridge_id(br);
465 spin_unlock_bh(&br->lock);
468 call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
470 netdev_update_features(br->dev);
475 void br_port_flags_change(struct net_bridge_port *p, unsigned long mask)
477 struct net_bridge *br = p->br;
479 if (mask & BR_AUTO_MASK)
480 nbp_update_port_count(br);