blob: a538cb1199a3087673790272b61c57a1f2630651 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Userspace interface
3 * Linux ethernet bridge
4 *
5 * Authors:
6 * Lennert Buytenhek <buytenh@gnu.org>
7 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * 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.
12 */
13
14#include <linux/kernel.h>
15#include <linux/netdevice.h>
stephen hemminger77f98592011-09-30 14:37:26 +000016#include <linux/etherdevice.h>
WANG Congc06ee962010-05-06 00:48:24 -070017#include <linux/netpoll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#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>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080023#include <linux/if_ether.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090024#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <net/sock.h>
Vlad Yasevich407af322013-02-13 12:00:12 +000026#include <linux/if_vlan.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
28#include "br_private.h"
29
30/*
31 * Determine initial path cost based on speed.
32 * using recommendations from 802.1d standard
33 *
Matthew Wilcox61a44b92007-07-31 14:00:02 -070034 * Since driver might sleep need to not be holding any locks.
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 */
Stephen Hemminger4433f422005-12-20 15:19:51 -080036static int port_cost(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070037{
Jiri Pirkofa3df922011-09-01 03:29:38 +000038 struct ethtool_cmd ecmd;
Stephen Hemmingerb4a488d2007-08-30 22:16:22 -070039
Jiri Pirko4bc71cb2011-09-03 03:34:30 +000040 if (!__ethtool_get_settings(dev, &ecmd)) {
Jiri Pirkofa3df922011-09-01 03:29:38 +000041 switch (ethtool_cmd_speed(&ecmd)) {
42 case SPEED_10000:
43 return 2;
44 case SPEED_1000:
45 return 4;
46 case SPEED_100:
47 return 19;
48 case SPEED_10:
49 return 100;
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 }
51 }
52
53 /* Old silly heuristics based on name */
54 if (!strncmp(dev->name, "lec", 3))
55 return 7;
56
57 if (!strncmp(dev->name, "plip", 4))
58 return 2500;
59
60 return 100; /* assume old 10Mbps */
61}
62
Stephen Hemminger4433f422005-12-20 15:19:51 -080063
tanxiaojun1a81a2e2013-12-16 21:32:46 +080064/* Check for port carrier transitions. */
Stephen Hemminger269def72007-02-22 01:10:18 -080065void br_port_carrier_check(struct net_bridge_port *p)
Stephen Hemminger4433f422005-12-20 15:19:51 -080066{
Stephen Hemminger269def72007-02-22 01:10:18 -080067 struct net_device *dev = p->dev;
68 struct net_bridge *br = p->br;
Stephen Hemmingerb3f1be42006-02-09 17:08:52 -080069
stephen hemminger8f3359b2013-04-13 14:06:07 +000070 if (!(p->flags & BR_ADMIN_COST) &&
71 netif_running(dev) && netif_oper_up(dev))
Stephen Hemminger6e86b892006-03-03 17:14:51 -080072 p->path_cost = port_cost(dev);
Stephen Hemminger4433f422005-12-20 15:19:51 -080073
stephen hemmingeraa7c6e52010-08-24 13:12:56 +000074 if (!netif_running(br->dev))
75 return;
76
77 spin_lock_bh(&br->lock);
stephen hemminger576eb622012-12-28 18:15:22 +000078 if (netif_running(dev) && netif_oper_up(dev)) {
stephen hemmingeraa7c6e52010-08-24 13:12:56 +000079 if (p->state == BR_STATE_DISABLED)
80 br_stp_enable_port(p);
81 } else {
82 if (p->state != BR_STATE_DISABLED)
83 br_stp_disable_port(p);
Stephen Hemminger4433f422005-12-20 15:19:51 -080084 }
stephen hemmingeraa7c6e52010-08-24 13:12:56 +000085 spin_unlock_bh(&br->lock);
Stephen Hemminger4433f422005-12-20 15:19:51 -080086}
87
Vlad Yasevich2796d0c2014-05-16 09:59:20 -040088static void br_port_set_promisc(struct net_bridge_port *p)
89{
90 int err = 0;
91
92 if (br_promisc_port(p))
93 return;
94
95 err = dev_set_promiscuity(p->dev, 1);
96 if (err)
97 return;
98
99 br_fdb_unsync_static(p->br, p);
100 p->flags |= BR_PROMISC;
101}
102
103static void br_port_clear_promisc(struct net_bridge_port *p)
104{
105 int err;
106
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
110 * it here.
111 */
112 if (!br_promisc_port(p) || !(p->dev->priv_flags & IFF_UNICAST_FLT))
113 return;
114
115 /* Since we'll be clearing the promisc mode, program the port
116 * first so that we don't have interruption in traffic.
117 */
118 err = br_fdb_sync_static(p->br, p);
119 if (err)
120 return;
121
122 dev_set_promiscuity(p->dev, -1);
123 p->flags &= ~BR_PROMISC;
124}
125
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.
130 */
131void br_manage_promisc(struct net_bridge *br)
132{
133 struct net_bridge_port *p;
134 bool set_all = false;
135
136 /* If vlan filtering is disabled or bridge interface is placed
137 * into promiscuous mode, place all ports in promiscuous mode.
138 */
139 if ((br->dev->flags & IFF_PROMISC) || !br_vlan_enabled(br))
140 set_all = true;
141
142 list_for_each_entry(p, &br->port_list, list) {
143 if (set_all) {
144 br_port_set_promisc(p);
145 } else {
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
154 * this config to hw.
155 */
Toshiaki Makitae0a47d12014-06-05 20:53:32 +0900156 if (br->auto_cnt == 0 ||
157 (br->auto_cnt == 1 && br_auto_port(p)))
Vlad Yasevich2796d0c2014-05-16 09:59:20 -0400158 br_port_clear_promisc(p);
159 else
160 br_port_set_promisc(p);
161 }
162 }
163}
164
Vlad Yaseviche028e4b2014-05-16 09:59:16 -0400165static void nbp_update_port_count(struct net_bridge *br)
166{
167 struct net_bridge_port *p;
168 u32 cnt = 0;
169
170 list_for_each_entry(p, &br->port_list, list) {
171 if (br_auto_port(p))
172 cnt++;
173 }
Vlad Yasevich2796d0c2014-05-16 09:59:20 -0400174 if (br->auto_cnt != cnt) {
175 br->auto_cnt = cnt;
176 br_manage_promisc(br);
177 }
178}
179
180static void nbp_delete_promisc(struct net_bridge_port *p)
181{
stephen hemminger025559e2014-05-16 20:46:17 -0700182 /* If port is currently promiscuous, unset promiscuity.
Vlad Yasevich2796d0c2014-05-16 09:59:20 -0400183 * Otherwise, it is a static port so remove all addresses
184 * from it.
185 */
186 dev_set_allmulti(p->dev, -1);
187 if (br_promisc_port(p))
188 dev_set_promiscuity(p->dev, -1);
189 else
190 br_fdb_unsync_static(p->br, p);
Vlad Yaseviche028e4b2014-05-16 09:59:16 -0400191}
192
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800193static void release_nbp(struct kobject *kobj)
194{
195 struct net_bridge_port *p
196 = container_of(kobj, struct net_bridge_port, kobj);
197 kfree(p);
198}
199
200static struct kobj_type brport_ktype = {
201#ifdef CONFIG_SYSFS
202 .sysfs_ops = &brport_sysfs_ops,
203#endif
204 .release = release_nbp,
205};
206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207static void destroy_nbp(struct net_bridge_port *p)
208{
209 struct net_device *dev = p->dev;
210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 p->br = NULL;
212 p->dev = NULL;
213 dev_put(dev);
214
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800215 kobject_put(&p->kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216}
217
218static void destroy_nbp_rcu(struct rcu_head *head)
219{
220 struct net_bridge_port *p =
221 container_of(head, struct net_bridge_port, rcu);
222 destroy_nbp(p);
223}
224
Stephen Hemminger3f4cfc22006-01-31 17:44:07 -0800225/* 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.
228 *
229 * Final cleanup doesn't occur until after all CPU's finished
230 * processing packets.
231 *
232 * Protected from multiple admin operations by RTNL mutex
233 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234static void del_nbp(struct net_bridge_port *p)
235{
236 struct net_bridge *br = p->br;
237 struct net_device *dev = p->dev;
238
Randy Dunlapb3bcb722010-05-18 12:26:27 -0700239 sysfs_remove_link(br->ifobj, p->dev->name);
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800240
Vlad Yasevich2796d0c2014-05-16 09:59:20 -0400241 nbp_delete_promisc(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
243 spin_lock_bh(&br->lock);
244 br_stp_disable_port(p);
245 spin_unlock_bh(&br->lock);
246
Stephen Hemmingerb86c4502007-03-22 14:08:46 -0700247 br_ifinfo_notify(RTM_DELLINK, p);
248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 list_del_rcu(&p->list);
250
Vlad Yasevich2796d0c2014-05-16 09:59:20 -0400251 nbp_vlan_flush(p);
Nikolay Aleksandrov1ea2d022015-06-23 05:28:16 -0700252 br_fdb_delete_by_port(br, p, 0, 1);
Vlad Yaseviche028e4b2014-05-16 09:59:16 -0400253 nbp_update_port_count(br);
254
Jiri Pirko0f495792014-09-05 15:51:28 +0200255 netdev_upper_dev_unlink(dev, br->dev);
256
Jiri Pirkof350a0a82010-06-15 06:50:45 +0000257 dev->priv_flags &= ~IFF_BRIDGE_PORT;
258
Jiri Pirkoab95bfe2010-06-01 21:52:08 +0000259 netdev_rx_handler_unregister(dev);
Stephen Hemmingerb3f1be42006-02-09 17:08:52 -0800260
Herbert Xu3fe2d7c2010-02-28 00:49:38 -0800261 br_multicast_del_port(p);
262
Stephen Hemminger125a12c2006-03-03 17:16:15 -0800263 kobject_uevent(&p->kobj, KOBJ_REMOVE);
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800264 kobject_del(&p->kobj);
265
Herbert Xu91d2c342010-06-10 16:12:50 +0000266 br_netpoll_disable(p);
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 call_rcu(&p->rcu, destroy_nbp_rcu);
269}
270
stephen hemminger1ce5cce2011-10-06 11:19:41 +0000271/* Delete bridge device */
272void br_dev_delete(struct net_device *dev, struct list_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273{
stephen hemminger1ce5cce2011-10-06 11:19:41 +0000274 struct net_bridge *br = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 struct net_bridge_port *p, *n;
276
277 list_for_each_entry_safe(p, n, &br->port_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 del_nbp(p);
279 }
280
Nikolay Aleksandrov1ea2d022015-06-23 05:28:16 -0700281 br_fdb_delete_by_port(br, NULL, 0, 1);
Ding Tianhongf8730422013-12-07 22:12:05 +0800282
Toshiaki Makitab4e09b22013-11-13 17:26:14 +0900283 br_vlan_flush(br);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 del_timer_sync(&br->gc_timer);
285
286 br_sysfs_delbr(br->dev);
Eric Dumazet8c56ba02009-10-28 05:35:35 +0000287 unregister_netdevice_queue(br->dev, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288}
289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290/* find an available port number */
291static int find_portno(struct net_bridge *br)
292{
293 int index;
294 struct net_bridge_port *p;
295 unsigned long *inuse;
296
Stephen Hemminger3b781fa2006-03-20 22:56:50 -0800297 inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 GFP_KERNEL);
299 if (!inuse)
300 return -ENOMEM;
301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 set_bit(0, inuse); /* zero is reserved */
303 list_for_each_entry(p, &br->port_list, list) {
304 set_bit(p->port_no, inuse);
305 }
306 index = find_first_zero_bit(inuse, BR_MAX_PORTS);
307 kfree(inuse);
308
309 return (index >= BR_MAX_PORTS) ? -EXFULL : index;
310}
311
Stephen Hemminger4433f422005-12-20 15:19:51 -0800312/* called with RTNL but without bridge lock */
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900313static struct net_bridge_port *new_nbp(struct net_bridge *br,
Stephen Hemminger4433f422005-12-20 15:19:51 -0800314 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
316 int index;
317 struct net_bridge_port *p;
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 index = find_portno(br);
320 if (index < 0)
321 return ERR_PTR(index);
322
Stephen Hemmingercee48542006-03-20 22:57:03 -0800323 p = kzalloc(sizeof(*p), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 if (p == NULL)
325 return ERR_PTR(-ENOMEM);
326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 p->br = br;
328 dev_hold(dev);
329 p->dev = dev;
Stephen Hemminger4433f422005-12-20 15:19:51 -0800330 p->path_cost = port_cost(dev);
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900331 p->priority = 0x8000 >> BR_PORT_BITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 p->port_no = index;
Vlad Yasevich2796d0c2014-05-16 09:59:20 -0400333 p->flags = BR_LEARNING | BR_FLOOD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 br_init_port(p);
Florian Fainelli775dd692014-09-30 16:13:19 -0700335 br_set_state(p, BR_STATE_DISABLED);
Stephen Hemmingerd32439c2006-03-03 17:15:34 -0800336 br_stp_port_timer_init(p);
Herbert Xu3fe2d7c2010-02-28 00:49:38 -0800337 br_multicast_add_port(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
339 return p;
340}
341
Alexey Dobriyan4aa678b2008-09-08 16:19:58 -0700342int br_add_bridge(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
344 struct net_device *dev;
Eric Dumazet11f3a6b2011-08-22 06:05:59 +0000345 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Tom Gundersenc835a672014-07-14 16:37:24 +0200347 dev = alloc_netdev(sizeof(struct net_bridge), name, NET_NAME_UNKNOWN,
stephen hemmingerbb900b22011-04-04 14:03:32 +0000348 br_dev_setup);
349
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900350 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 return -ENOMEM;
352
stephen hemmingerbb900b22011-04-04 14:03:32 +0000353 dev_net_set(dev, net);
stephen hemminger149ddd82012-06-26 05:48:45 +0000354 dev->rtnl_link_ops = &br_link_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Eric Dumazet11f3a6b2011-08-22 06:05:59 +0000356 res = register_netdev(dev);
357 if (res)
358 free_netdev(dev);
359 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360}
361
Alexey Dobriyan4aa678b2008-09-08 16:19:58 -0700362int br_del_bridge(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363{
364 struct net_device *dev;
365 int ret = 0;
366
367 rtnl_lock();
Alexey Dobriyan4aa678b2008-09-08 16:19:58 -0700368 dev = __dev_get_by_name(net, name);
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900369 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 ret = -ENXIO; /* Could not find device */
371
372 else if (!(dev->priv_flags & IFF_EBRIDGE)) {
373 /* Attempt to delete non bridge device! */
374 ret = -EPERM;
375 }
376
377 else if (dev->flags & IFF_UP) {
378 /* Not shutdown yet. */
379 ret = -EBUSY;
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900380 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900382 else
stephen hemminger1ce5cce2011-10-06 11:19:41 +0000383 br_dev_delete(dev, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
385 rtnl_unlock();
386 return ret;
387}
388
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800389/* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390int br_min_mtu(const struct net_bridge *br)
391{
392 const struct net_bridge_port *p;
393 int mtu = 0;
394
395 ASSERT_RTNL();
396
397 if (list_empty(&br->port_list))
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800398 mtu = ETH_DATA_LEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 else {
400 list_for_each_entry(p, &br->port_list, list) {
401 if (!mtu || p->dev->mtu < mtu)
402 mtu = p->dev->mtu;
403 }
404 }
405 return mtu;
406}
407
Stephen Hemminger81d35302005-05-29 14:15:17 -0700408/*
409 * Recomputes features using slave's features
410 */
Michał Mirosławc8f44af2011-11-15 15:29:55 +0000411netdev_features_t br_features_recompute(struct net_bridge *br,
412 netdev_features_t features)
Stephen Hemminger81d35302005-05-29 14:15:17 -0700413{
414 struct net_bridge_port *p;
Michał Mirosławc8f44af2011-11-15 15:29:55 +0000415 netdev_features_t mask;
Stephen Hemminger81d35302005-05-29 14:15:17 -0700416
Herbert Xub63365a2008-10-23 01:11:29 -0700417 if (list_empty(&br->port_list))
Michał Mirosławc4d27ef2011-04-22 06:31:16 +0000418 return features;
Herbert Xub63365a2008-10-23 01:11:29 -0700419
Michał Mirosławc4d27ef2011-04-22 06:31:16 +0000420 mask = features;
Herbert Xub63365a2008-10-23 01:11:29 -0700421 features &= ~NETIF_F_ONE_FOR_ALL;
Stephen Hemminger81d35302005-05-29 14:15:17 -0700422
423 list_for_each_entry(p, &br->port_list, list) {
Herbert Xub63365a2008-10-23 01:11:29 -0700424 features = netdev_increment_features(features,
425 p->dev->features, mask);
Stephen Hemminger81d35302005-05-29 14:15:17 -0700426 }
Toshiaki Makitaf902e882015-01-09 14:16:40 +0900427 features = netdev_add_tso_features(features, mask);
Stephen Hemminger81d35302005-05-29 14:15:17 -0700428
Michał Mirosławc4d27ef2011-04-22 06:31:16 +0000429 return features;
Stephen Hemminger81d35302005-05-29 14:15:17 -0700430}
431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432/* called with RTNL */
433int br_add_if(struct net_bridge *br, struct net_device *dev)
434{
435 struct net_bridge_port *p;
436 int err = 0;
stephen hemmingeredf947f2011-03-24 13:24:01 +0000437 bool changed_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Florian Fainelli8db0a2e2015-01-16 09:56:02 -0800439 /* Don't allow bridging non-ethernet like devices, or DSA-enabled
440 * master network devices since the bridge layer rx_handler prevents
441 * the DSA fake ethertype handler to be invoked, so we do not strip off
442 * the DSA switch tag protocol header and the bridge layer just return
443 * RX_HANDLER_CONSUMED, stopping RX processing for these frames.
444 */
Stephen Hemminger1056bd52009-11-05 20:46:52 -0800445 if ((dev->flags & IFF_LOOPBACK) ||
stephen hemminger77f98592011-09-30 14:37:26 +0000446 dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN ||
Florian Fainelli8db0a2e2015-01-16 09:56:02 -0800447 !is_valid_ether_addr(dev->dev_addr) ||
448 netdev_uses_dsa(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 return -EINVAL;
450
Stephen Hemminger1056bd52009-11-05 20:46:52 -0800451 /* No bridging of bridges */
Stephen Hemminger00829822008-11-20 20:14:53 -0800452 if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return -ELOOP;
454
Stephen Hemminger1056bd52009-11-05 20:46:52 -0800455 /* Device is already being bridged */
Jiri Pirkof350a0a82010-06-15 06:50:45 +0000456 if (br_port_exists(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 return -EBUSY;
458
Johannes Bergad4bb6f2009-11-19 00:56:30 +0100459 /* No bridging devices that dislike that (e.g. wireless) */
460 if (dev->priv_flags & IFF_DONT_BRIDGE)
461 return -EOPNOTSUPP;
462
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800463 p = new_nbp(br, dev);
464 if (IS_ERR(p))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 return PTR_ERR(p);
466
Amerigo Wangbb8ed632011-05-19 21:39:11 +0000467 call_netdevice_notifiers(NETDEV_JOIN, dev);
468
Vlad Yasevich2796d0c2014-05-16 09:59:20 -0400469 err = dev_set_allmulti(dev, 1);
Wang Chenbc3f9072008-07-14 20:53:13 -0700470 if (err)
471 goto put_back;
472
Greg Kroah-Hartmane32cc732007-12-17 23:05:35 -0700473 err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
474 SYSFS_BRIDGE_PORT_ATTR);
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800475 if (err)
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800476 goto err1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800478 err = br_sysfs_addif(p);
479 if (err)
480 goto err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
Eric W. Biedermana8779ec2014-03-27 15:36:38 -0700482 err = br_netpoll_enable(p);
stephen hemminger93d8bf92013-07-24 11:51:41 -0700483 if (err)
Herbert Xu91d2c342010-06-10 16:12:50 +0000484 goto err3;
485
Jiri Pirko0f495792014-09-05 15:51:28 +0200486 err = netdev_rx_handler_register(dev, br_handle_frame, p);
Jiri Pirkoab95bfe2010-06-01 21:52:08 +0000487 if (err)
Gao feng9b1536c2012-12-19 23:41:43 +0000488 goto err4;
Jiri Pirkof350a0a82010-06-15 06:50:45 +0000489
Jiri Pirko0f495792014-09-05 15:51:28 +0200490 dev->priv_flags |= IFF_BRIDGE_PORT;
491
492 err = netdev_master_upper_dev_link(dev, br->dev);
Jiri Pirkoafc61512011-02-13 09:33:42 +0000493 if (err)
Gao feng9b1536c2012-12-19 23:41:43 +0000494 goto err5;
Jiri Pirkoafc61512011-02-13 09:33:42 +0000495
Ben Hutchings0187bdf2008-06-19 16:15:47 -0700496 dev_disable_lro(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800498 list_add_rcu(&p->list, &br->port_list);
499
Vlad Yaseviche028e4b2014-05-16 09:59:16 -0400500 nbp_update_port_count(br);
501
Michał Mirosławc4d27ef2011-04-22 06:31:16 +0000502 netdev_update_features(br->dev);
503
Florian Fainellifd094802013-08-27 12:03:53 +0100504 if (br->dev->needed_headroom < dev->needed_headroom)
505 br->dev->needed_headroom = dev->needed_headroom;
506
Toshiaki Makitaa4b816d2014-02-07 16:48:21 +0900507 if (br_fdb_insert(br, p, dev->dev_addr, 0))
508 netdev_err(dev, "failed insert local address bridge forwarding table\n");
509
Vlad Yasevich5be5a2d2014-10-03 11:29:18 -0400510 if (nbp_vlan_init(p))
511 netdev_err(dev, "failed to initialize vlan filtering on this port\n");
512
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800513 spin_lock_bh(&br->lock);
stephen hemmingeredf947f2011-03-24 13:24:01 +0000514 changed_addr = br_stp_recalculate_bridge_id(br);
Aji Srinivasde790592007-03-07 16:10:53 -0800515
stephen hemminger576eb622012-12-28 18:15:22 +0000516 if (netif_running(dev) && netif_oper_up(dev) &&
Aji Srinivasde790592007-03-07 16:10:53 -0800517 (br->dev->flags & IFF_UP))
518 br_stp_enable_port(p);
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800519 spin_unlock_bh(&br->lock);
520
Stephen Hemmingerb86c4502007-03-22 14:08:46 -0700521 br_ifinfo_notify(RTM_NEWLINK, p);
522
stephen hemmingeredf947f2011-03-24 13:24:01 +0000523 if (changed_addr)
stephen hemminger56139fc2011-07-22 07:47:08 +0000524 call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
stephen hemmingeredf947f2011-03-24 13:24:01 +0000525
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800526 dev_set_mtu(br->dev, br_min_mtu(br));
Stephen Hemminger269def72007-02-22 01:10:18 -0800527
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800528 kobject_uevent(&p->kobj, KOBJ_ADD);
529
530 return 0;
Jiri Pirkoafc61512011-02-13 09:33:42 +0000531
Gao feng9b1536c2012-12-19 23:41:43 +0000532err5:
Jiri Pirko0f495792014-09-05 15:51:28 +0200533 dev->priv_flags &= ~IFF_BRIDGE_PORT;
534 netdev_rx_handler_unregister(dev);
Gao feng9b1536c2012-12-19 23:41:43 +0000535err4:
536 br_netpoll_disable(p);
Herbert Xu91d2c342010-06-10 16:12:50 +0000537err3:
538 sysfs_remove_link(br->ifobj, p->dev->name);
Stephen Hemmingerbab1dee2006-02-09 17:10:12 -0800539err2:
Xiaotian Fengc587aea2009-07-23 23:06:32 +0000540 kobject_put(&p->kobj);
Jeff Hansen30df94f2009-09-28 12:54:25 -0700541 p = NULL; /* kobject_put frees */
stephen hemminger77f98592011-09-30 14:37:26 +0000542err1:
wangweidong019ee792014-05-29 10:15:30 +0800543 dev_set_allmulti(dev, -1);
Volodymyr G Lukiianyk43af8532008-04-29 03:17:42 -0700544put_back:
545 dev_put(dev);
Wang Chenbc3f9072008-07-14 20:53:13 -0700546 kfree(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 return err;
548}
549
550/* called with RTNL */
551int br_del_if(struct net_bridge *br, struct net_device *dev)
552{
Jiri Pirkof350a0a82010-06-15 06:50:45 +0000553 struct net_bridge_port *p;
Andrei Warkentin9be6dd62011-08-05 11:04:10 +0000554 bool changed_addr;
YOSHIFUJI Hideaki9d6f2292007-02-09 23:24:35 +0900555
Eric Dumazetec1e5612010-11-15 06:38:14 +0000556 p = br_port_get_rtnl(dev);
stephen hemmingerb5ed54e2010-11-15 06:38:13 +0000557 if (!p || p->br != br)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return -EINVAL;
559
Amerigo Wangd30362c2012-08-10 01:24:43 +0000560 /* Since more than one interface can be attached to a bridge,
561 * there still maybe an alternate path for netconsole to use;
562 * therefore there is no reason for a NETDEV_RELEASE event.
563 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 del_nbp(p);
565
Venkat Venkatsubra4c906c22015-03-13 07:08:22 -0700566 dev_set_mtu(br->dev, br_min_mtu(br));
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 spin_lock_bh(&br->lock);
Andrei Warkentin9be6dd62011-08-05 11:04:10 +0000569 changed_addr = br_stp_recalculate_bridge_id(br);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 spin_unlock_bh(&br->lock);
571
Andrei Warkentin9be6dd62011-08-05 11:04:10 +0000572 if (changed_addr)
573 call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
574
Michał Mirosławc4d27ef2011-04-22 06:31:16 +0000575 netdev_update_features(br->dev);
576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 return 0;
578}
Vlad Yaseviche028e4b2014-05-16 09:59:16 -0400579
580void br_port_flags_change(struct net_bridge_port *p, unsigned long mask)
581{
582 struct net_bridge *br = p->br;
583
584 if (mask & BR_AUTO_MASK)
585 nbp_update_port_count(br);
586}