]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - net/bridge/br_if.c
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 br
->stats
= alloc_percpu(struct br_cpu_netstats
);
195 spin_lock_init(&br
->lock
);
196 INIT_LIST_HEAD(&br
->port_list
);
197 spin_lock_init(&br
->hash_lock
);
199 br
->bridge_id
.prio
[0] = 0x80;
200 br
->bridge_id
.prio
[1] = 0x00;
202 memcpy(br
->group_addr
, br_group_address
, ETH_ALEN
);
204 br
->feature_mask
= dev
->features
;
205 br
->stp_enabled
= BR_NO_STP
;
206 br
->designated_root
= br
->bridge_id
;
207 br
->root_path_cost
= 0;
209 br
->bridge_max_age
= br
->max_age
= 20 * HZ
;
210 br
->bridge_hello_time
= br
->hello_time
= 2 * HZ
;
211 br
->bridge_forward_delay
= br
->forward_delay
= 15 * HZ
;
212 br
->topology_change
= 0;
213 br
->topology_change_detected
= 0;
214 br
->ageing_time
= 300 * HZ
;
216 br_netfilter_rtable_init(br
);
218 br_stp_timer_init(br
);
219 br_multicast_init(br
);
224 /* find an available port number */
225 static int find_portno(struct net_bridge
*br
)
228 struct net_bridge_port
*p
;
229 unsigned long *inuse
;
231 inuse
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
236 set_bit(0, inuse
); /* zero is reserved */
237 list_for_each_entry(p
, &br
->port_list
, list
) {
238 set_bit(p
->port_no
, inuse
);
240 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
243 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
246 /* called with RTNL but without bridge lock */
247 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
248 struct net_device
*dev
)
251 struct net_bridge_port
*p
;
253 index
= find_portno(br
);
255 return ERR_PTR(index
);
257 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
259 return ERR_PTR(-ENOMEM
);
264 p
->path_cost
= port_cost(dev
);
265 p
->priority
= 0x8000 >> BR_PORT_BITS
;
269 p
->state
= BR_STATE_DISABLED
;
270 br_stp_port_timer_init(p
);
271 br_multicast_add_port(p
);
276 static struct device_type br_type
= {
280 int br_add_bridge(struct net
*net
, const char *name
)
282 struct net_device
*dev
;
285 dev
= new_bridge_dev(net
, name
);
290 if (strchr(dev
->name
, '%')) {
291 ret
= dev_alloc_name(dev
, dev
->name
);
296 SET_NETDEV_DEVTYPE(dev
, &br_type
);
298 ret
= register_netdevice(dev
);
302 ret
= br_sysfs_addbr(dev
);
304 unregister_netdevice(dev
);
314 int br_del_bridge(struct net
*net
, const char *name
)
316 struct net_device
*dev
;
320 dev
= __dev_get_by_name(net
, name
);
322 ret
= -ENXIO
; /* Could not find device */
324 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
325 /* Attempt to delete non bridge device! */
329 else if (dev
->flags
& IFF_UP
) {
330 /* Not shutdown yet. */
335 del_br(netdev_priv(dev
), NULL
);
341 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
342 int br_min_mtu(const struct net_bridge
*br
)
344 const struct net_bridge_port
*p
;
349 if (list_empty(&br
->port_list
))
352 list_for_each_entry(p
, &br
->port_list
, list
) {
353 if (!mtu
|| p
->dev
->mtu
< mtu
)
361 * Recomputes features using slave's features
363 void br_features_recompute(struct net_bridge
*br
)
365 struct net_bridge_port
*p
;
366 unsigned long features
, mask
;
368 features
= mask
= br
->feature_mask
;
369 if (list_empty(&br
->port_list
))
372 features
&= ~NETIF_F_ONE_FOR_ALL
;
374 list_for_each_entry(p
, &br
->port_list
, list
) {
375 features
= netdev_increment_features(features
,
376 p
->dev
->features
, mask
);
380 br
->dev
->features
= netdev_fix_features(features
, NULL
);
383 /* called with RTNL */
384 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
386 struct net_bridge_port
*p
;
389 /* Don't allow bridging non-ethernet like devices */
390 if ((dev
->flags
& IFF_LOOPBACK
) ||
391 dev
->type
!= ARPHRD_ETHER
|| dev
->addr_len
!= ETH_ALEN
)
394 /* No bridging of bridges */
395 if (dev
->netdev_ops
->ndo_start_xmit
== br_dev_xmit
)
398 /* Device is already being bridged */
399 if (dev
->br_port
!= NULL
)
402 /* No bridging devices that dislike that (e.g. wireless) */
403 if (dev
->priv_flags
& IFF_DONT_BRIDGE
)
406 p
= new_nbp(br
, dev
);
410 err
= dev_set_promiscuity(dev
, 1);
414 err
= kobject_init_and_add(&p
->kobj
, &brport_ktype
, &(dev
->dev
.kobj
),
415 SYSFS_BRIDGE_PORT_ATTR
);
419 err
= br_fdb_insert(br
, p
, dev
->dev_addr
);
423 err
= br_sysfs_addif(p
);
427 rcu_assign_pointer(dev
->br_port
, p
);
428 dev_disable_lro(dev
);
430 list_add_rcu(&p
->list
, &br
->port_list
);
432 spin_lock_bh(&br
->lock
);
433 br_stp_recalculate_bridge_id(br
);
434 br_features_recompute(br
);
436 if ((dev
->flags
& IFF_UP
) && netif_carrier_ok(dev
) &&
437 (br
->dev
->flags
& IFF_UP
))
438 br_stp_enable_port(p
);
439 spin_unlock_bh(&br
->lock
);
441 br_ifinfo_notify(RTM_NEWLINK
, p
);
443 dev_set_mtu(br
->dev
, br_min_mtu(br
));
445 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
449 br_fdb_delete_by_port(br
, p
, 1);
451 kobject_put(&p
->kobj
);
452 p
= NULL
; /* kobject_put frees */
454 dev_set_promiscuity(dev
, -1);
461 /* called with RTNL */
462 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
464 struct net_bridge_port
*p
= dev
->br_port
;
466 if (!p
|| p
->br
!= br
)
471 spin_lock_bh(&br
->lock
);
472 br_stp_recalculate_bridge_id(br
);
473 br_features_recompute(br
);
474 spin_unlock_bh(&br
->lock
);
479 void __net_exit
br_net_exit(struct net
*net
)
481 struct net_device
*dev
;
485 for_each_netdev(net
, dev
)
486 if (dev
->priv_flags
& IFF_EBRIDGE
)
487 del_br(netdev_priv(dev
), &list
);
489 unregister_netdevice_many(&list
);