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 br_port_set_promisc(struct net_bridge_port
*p
)
92 if (br_promisc_port(p
))
95 err
= dev_set_promiscuity(p
->dev
, 1);
99 br_fdb_unsync_static(p
->br
, p
);
100 p
->flags
|= BR_PROMISC
;
103 static void br_port_clear_promisc(struct net_bridge_port
*p
)
107 /* Check if the port is already non-promisc or if it doesn't
108 * support UNICAST filtering. Without unicast filtering support
109 * we'll end up re-enabling promisc mode anyway, so just check for
112 if (!br_promisc_port(p
) || !(p
->dev
->priv_flags
& IFF_UNICAST_FLT
))
115 /* Since we'll be clearing the promisc mode, program the port
116 * first so that we don't have interruption in traffic.
118 err
= br_fdb_sync_static(p
->br
, p
);
122 dev_set_promiscuity(p
->dev
, -1);
123 p
->flags
&= ~BR_PROMISC
;
126 /* When a port is added or removed or when certain port flags
127 * change, this function is called to automatically manage
128 * promiscuity setting of all the bridge ports. We are always called
129 * under RTNL so can skip using rcu primitives.
131 void br_manage_promisc(struct net_bridge
*br
)
133 struct net_bridge_port
*p
;
134 bool set_all
= false;
136 /* If vlan filtering is disabled or bridge interface is placed
137 * into promiscuous mode, place all ports in promiscuous mode.
139 if ((br
->dev
->flags
& IFF_PROMISC
) || !br_vlan_enabled(br
))
142 list_for_each_entry(p
, &br
->port_list
, list
) {
144 br_port_set_promisc(p
);
146 /* If the number of auto-ports is <= 1, then all other
147 * ports will have their output configuration
148 * statically specified through fdbs. Since ingress
149 * on the auto-port becomes forwarding/egress to other
150 * ports and egress configuration is statically known,
151 * we can say that ingress configuration of the
152 * auto-port is also statically known.
153 * This lets us disable promiscuous mode and write
156 if (br
->auto_cnt
== 0 ||
157 (br
->auto_cnt
== 1 && br_auto_port(p
)))
158 br_port_clear_promisc(p
);
160 br_port_set_promisc(p
);
165 static void nbp_update_port_count(struct net_bridge
*br
)
167 struct net_bridge_port
*p
;
170 list_for_each_entry(p
, &br
->port_list
, list
) {
174 if (br
->auto_cnt
!= cnt
) {
176 br_manage_promisc(br
);
180 static void nbp_delete_promisc(struct net_bridge_port
*p
)
182 /* If port is currently promiscuous, unset promiscuity.
183 * Otherwise, it is a static port so remove all addresses
186 dev_set_allmulti(p
->dev
, -1);
187 if (br_promisc_port(p
))
188 dev_set_promiscuity(p
->dev
, -1);
190 br_fdb_unsync_static(p
->br
, p
);
193 static void release_nbp(struct kobject
*kobj
)
195 struct net_bridge_port
*p
196 = container_of(kobj
, struct net_bridge_port
, kobj
);
200 static struct kobj_type brport_ktype
= {
202 .sysfs_ops
= &brport_sysfs_ops
,
204 .release
= release_nbp
,
207 static void destroy_nbp(struct net_bridge_port
*p
)
209 struct net_device
*dev
= p
->dev
;
215 kobject_put(&p
->kobj
);
218 static void destroy_nbp_rcu(struct rcu_head
*head
)
220 struct net_bridge_port
*p
=
221 container_of(head
, struct net_bridge_port
, rcu
);
225 /* Delete port(interface) from bridge is done in two steps.
226 * via RCU. First step, marks device as down. That deletes
227 * all the timers and stops new packets from flowing through.
229 * Final cleanup doesn't occur until after all CPU's finished
230 * processing packets.
232 * Protected from multiple admin operations by RTNL mutex
234 static void del_nbp(struct net_bridge_port
*p
)
236 struct net_bridge
*br
= p
->br
;
237 struct net_device
*dev
= p
->dev
;
239 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
241 nbp_delete_promisc(p
);
243 spin_lock_bh(&br
->lock
);
244 br_stp_disable_port(p
);
245 spin_unlock_bh(&br
->lock
);
247 br_ifinfo_notify(RTM_DELLINK
, p
);
249 list_del_rcu(&p
->list
);
252 br_fdb_delete_by_port(br
, p
, 0, 1);
253 nbp_update_port_count(br
);
255 netdev_upper_dev_unlink(dev
, br
->dev
);
257 dev
->priv_flags
&= ~IFF_BRIDGE_PORT
;
259 netdev_rx_handler_unregister(dev
);
261 br_multicast_del_port(p
);
263 kobject_uevent(&p
->kobj
, KOBJ_REMOVE
);
264 kobject_del(&p
->kobj
);
266 br_netpoll_disable(p
);
268 call_rcu(&p
->rcu
, destroy_nbp_rcu
);
271 /* Delete bridge device */
272 void br_dev_delete(struct net_device
*dev
, struct list_head
*head
)
274 struct net_bridge
*br
= netdev_priv(dev
);
275 struct net_bridge_port
*p
, *n
;
277 list_for_each_entry_safe(p
, n
, &br
->port_list
, list
) {
281 br_fdb_delete_by_port(br
, NULL
, 0, 1);
284 br_multicast_dev_del(br
);
285 del_timer_sync(&br
->gc_timer
);
287 br_sysfs_delbr(br
->dev
);
288 unregister_netdevice_queue(br
->dev
, head
);
291 /* find an available port number */
292 static int find_portno(struct net_bridge
*br
)
295 struct net_bridge_port
*p
;
296 unsigned long *inuse
;
298 inuse
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
303 set_bit(0, inuse
); /* zero is reserved */
304 list_for_each_entry(p
, &br
->port_list
, list
) {
305 set_bit(p
->port_no
, inuse
);
307 index
= find_first_zero_bit(inuse
, BR_MAX_PORTS
);
310 return (index
>= BR_MAX_PORTS
) ? -EXFULL
: index
;
313 /* called with RTNL but without bridge lock */
314 static struct net_bridge_port
*new_nbp(struct net_bridge
*br
,
315 struct net_device
*dev
)
318 struct net_bridge_port
*p
;
320 index
= find_portno(br
);
322 return ERR_PTR(index
);
324 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
326 return ERR_PTR(-ENOMEM
);
331 p
->path_cost
= port_cost(dev
);
332 p
->priority
= 0x8000 >> BR_PORT_BITS
;
334 p
->flags
= BR_LEARNING
| BR_FLOOD
;
336 br_set_state(p
, BR_STATE_DISABLED
);
337 br_stp_port_timer_init(p
);
338 br_multicast_add_port(p
);
343 int br_add_bridge(struct net
*net
, const char *name
)
345 struct net_device
*dev
;
348 dev
= alloc_netdev(sizeof(struct net_bridge
), name
, NET_NAME_UNKNOWN
,
354 dev_net_set(dev
, net
);
355 dev
->rtnl_link_ops
= &br_link_ops
;
357 res
= register_netdev(dev
);
363 int br_del_bridge(struct net
*net
, const char *name
)
365 struct net_device
*dev
;
369 dev
= __dev_get_by_name(net
, name
);
371 ret
= -ENXIO
; /* Could not find device */
373 else if (!(dev
->priv_flags
& IFF_EBRIDGE
)) {
374 /* Attempt to delete non bridge device! */
378 else if (dev
->flags
& IFF_UP
) {
379 /* Not shutdown yet. */
384 br_dev_delete(dev
, NULL
);
390 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
391 int br_min_mtu(const struct net_bridge
*br
)
393 const struct net_bridge_port
*p
;
398 if (list_empty(&br
->port_list
))
401 list_for_each_entry(p
, &br
->port_list
, list
) {
402 if (!mtu
|| p
->dev
->mtu
< mtu
)
410 * Recomputes features using slave's features
412 netdev_features_t
br_features_recompute(struct net_bridge
*br
,
413 netdev_features_t features
)
415 struct net_bridge_port
*p
;
416 netdev_features_t mask
;
418 if (list_empty(&br
->port_list
))
422 features
&= ~NETIF_F_ONE_FOR_ALL
;
424 list_for_each_entry(p
, &br
->port_list
, list
) {
425 features
= netdev_increment_features(features
,
426 p
->dev
->features
, mask
);
428 features
= netdev_add_tso_features(features
, mask
);
433 /* called with RTNL */
434 int br_add_if(struct net_bridge
*br
, struct net_device
*dev
)
436 struct net_bridge_port
*p
;
440 /* Don't allow bridging non-ethernet like devices, or DSA-enabled
441 * master network devices since the bridge layer rx_handler prevents
442 * the DSA fake ethertype handler to be invoked, so we do not strip off
443 * the DSA switch tag protocol header and the bridge layer just return
444 * RX_HANDLER_CONSUMED, stopping RX processing for these frames.
446 if ((dev
->flags
& IFF_LOOPBACK
) ||
447 dev
->type
!= ARPHRD_ETHER
|| dev
->addr_len
!= ETH_ALEN
||
448 !is_valid_ether_addr(dev
->dev_addr
) ||
449 netdev_uses_dsa(dev
))
452 /* No bridging of bridges */
453 if (dev
->netdev_ops
->ndo_start_xmit
== br_dev_xmit
)
456 /* Device is already being bridged */
457 if (br_port_exists(dev
))
460 /* No bridging devices that dislike that (e.g. wireless) */
461 if (dev
->priv_flags
& IFF_DONT_BRIDGE
)
464 p
= new_nbp(br
, dev
);
468 call_netdevice_notifiers(NETDEV_JOIN
, dev
);
470 err
= dev_set_allmulti(dev
, 1);
474 err
= kobject_init_and_add(&p
->kobj
, &brport_ktype
, &(dev
->dev
.kobj
),
475 SYSFS_BRIDGE_PORT_ATTR
);
479 err
= br_sysfs_addif(p
);
483 err
= br_netpoll_enable(p
);
487 err
= netdev_rx_handler_register(dev
, br_handle_frame
, p
);
491 dev
->priv_flags
|= IFF_BRIDGE_PORT
;
493 err
= netdev_master_upper_dev_link(dev
, br
->dev
);
497 dev_disable_lro(dev
);
499 list_add_rcu(&p
->list
, &br
->port_list
);
501 nbp_update_port_count(br
);
503 netdev_update_features(br
->dev
);
505 if (br
->dev
->needed_headroom
< dev
->needed_headroom
)
506 br
->dev
->needed_headroom
= dev
->needed_headroom
;
508 if (br_fdb_insert(br
, p
, dev
->dev_addr
, 0))
509 netdev_err(dev
, "failed insert local address bridge forwarding table\n");
511 if (nbp_vlan_init(p
))
512 netdev_err(dev
, "failed to initialize vlan filtering on this port\n");
514 spin_lock_bh(&br
->lock
);
515 changed_addr
= br_stp_recalculate_bridge_id(br
);
517 if (netif_running(dev
) && netif_oper_up(dev
) &&
518 (br
->dev
->flags
& IFF_UP
))
519 br_stp_enable_port(p
);
520 spin_unlock_bh(&br
->lock
);
522 br_ifinfo_notify(RTM_NEWLINK
, p
);
525 call_netdevice_notifiers(NETDEV_CHANGEADDR
, br
->dev
);
527 dev_set_mtu(br
->dev
, br_min_mtu(br
));
529 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
534 dev
->priv_flags
&= ~IFF_BRIDGE_PORT
;
535 netdev_rx_handler_unregister(dev
);
537 br_netpoll_disable(p
);
539 sysfs_remove_link(br
->ifobj
, p
->dev
->name
);
541 kobject_put(&p
->kobj
);
542 p
= NULL
; /* kobject_put frees */
544 dev_set_allmulti(dev
, -1);
551 /* called with RTNL */
552 int br_del_if(struct net_bridge
*br
, struct net_device
*dev
)
554 struct net_bridge_port
*p
;
557 p
= br_port_get_rtnl(dev
);
558 if (!p
|| p
->br
!= br
)
561 /* Since more than one interface can be attached to a bridge,
562 * there still maybe an alternate path for netconsole to use;
563 * therefore there is no reason for a NETDEV_RELEASE event.
567 dev_set_mtu(br
->dev
, br_min_mtu(br
));
569 spin_lock_bh(&br
->lock
);
570 changed_addr
= br_stp_recalculate_bridge_id(br
);
571 spin_unlock_bh(&br
->lock
);
574 call_netdevice_notifiers(NETDEV_CHANGEADDR
, br
->dev
);
576 netdev_update_features(br
->dev
);
581 void br_port_flags_change(struct net_bridge_port
*p
, unsigned long mask
)
583 struct net_bridge
*br
= p
->br
;
585 if (mask
& BR_AUTO_MASK
)
586 nbp_update_port_count(br
);