xref: /openbmc/linux/net/bridge/br_if.c (revision 565d76cb)
1 /*
2  *	Userspace interface
3  *	Linux ethernet bridge
4  *
5  *	Authors:
6  *	Lennert Buytenhek		<buytenh@gnu.org>
7  *
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.
12  */
13 
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>
24 #include <net/sock.h>
25 
26 #include "br_private.h"
27 
28 /*
29  * Determine initial path cost based on speed.
30  * using recommendations from 802.1d standard
31  *
32  * Since driver might sleep need to not be holding any locks.
33  */
34 static int port_cost(struct net_device *dev)
35 {
36 	if (dev->ethtool_ops && dev->ethtool_ops->get_settings) {
37 		struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET, };
38 
39 		if (!dev->ethtool_ops->get_settings(dev, &ecmd)) {
40 			switch(ecmd.speed) {
41 			case SPEED_10000:
42 				return 2;
43 			case SPEED_1000:
44 				return 4;
45 			case SPEED_100:
46 				return 19;
47 			case SPEED_10:
48 				return 100;
49 			}
50 		}
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 
63 
64 /* Check for port carrier transistions. */
65 void br_port_carrier_check(struct net_bridge_port *p)
66 {
67 	struct net_device *dev = p->dev;
68 	struct net_bridge *br = p->br;
69 
70 	if (netif_running(dev) && netif_carrier_ok(dev))
71 		p->path_cost = port_cost(dev);
72 
73 	if (!netif_running(br->dev))
74 		return;
75 
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);
80 	} else {
81 		if (p->state != BR_STATE_DISABLED)
82 			br_stp_disable_port(p);
83 	}
84 	spin_unlock_bh(&br->lock);
85 }
86 
87 static void release_nbp(struct kobject *kobj)
88 {
89 	struct net_bridge_port *p
90 		= container_of(kobj, struct net_bridge_port, kobj);
91 	kfree(p);
92 }
93 
94 static struct kobj_type brport_ktype = {
95 #ifdef CONFIG_SYSFS
96 	.sysfs_ops = &brport_sysfs_ops,
97 #endif
98 	.release = release_nbp,
99 };
100 
101 static void destroy_nbp(struct net_bridge_port *p)
102 {
103 	struct net_device *dev = p->dev;
104 
105 	p->br = NULL;
106 	p->dev = NULL;
107 	dev_put(dev);
108 
109 	kobject_put(&p->kobj);
110 }
111 
112 static void destroy_nbp_rcu(struct rcu_head *head)
113 {
114 	struct net_bridge_port *p =
115 			container_of(head, struct net_bridge_port, rcu);
116 	destroy_nbp(p);
117 }
118 
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.
122  *
123  * Final cleanup doesn't occur until after all CPU's finished
124  * processing packets.
125  *
126  * Protected from multiple admin operations by RTNL mutex
127  */
128 static void del_nbp(struct net_bridge_port *p)
129 {
130 	struct net_bridge *br = p->br;
131 	struct net_device *dev = p->dev;
132 
133 	sysfs_remove_link(br->ifobj, p->dev->name);
134 
135 	dev_set_promiscuity(dev, -1);
136 
137 	spin_lock_bh(&br->lock);
138 	br_stp_disable_port(p);
139 	spin_unlock_bh(&br->lock);
140 
141 	br_ifinfo_notify(RTM_DELLINK, p);
142 
143 	br_fdb_delete_by_port(br, p, 1);
144 
145 	list_del_rcu(&p->list);
146 
147 	dev->priv_flags &= ~IFF_BRIDGE_PORT;
148 
149 	netdev_rx_handler_unregister(dev);
150 
151 	netdev_set_master(dev, NULL);
152 
153 	br_multicast_del_port(p);
154 
155 	kobject_uevent(&p->kobj, KOBJ_REMOVE);
156 	kobject_del(&p->kobj);
157 
158 	br_netpoll_disable(p);
159 
160 	call_rcu(&p->rcu, destroy_nbp_rcu);
161 }
162 
163 /* called with RTNL */
164 static void del_br(struct net_bridge *br, struct list_head *head)
165 {
166 	struct net_bridge_port *p, *n;
167 
168 	list_for_each_entry_safe(p, n, &br->port_list, list) {
169 		del_nbp(p);
170 	}
171 
172 	del_timer_sync(&br->gc_timer);
173 
174 	br_sysfs_delbr(br->dev);
175 	unregister_netdevice_queue(br->dev, head);
176 }
177 
178 static struct net_device *new_bridge_dev(struct net *net, const char *name)
179 {
180 	struct net_bridge *br;
181 	struct net_device *dev;
182 
183 	dev = alloc_netdev(sizeof(struct net_bridge), name,
184 			   br_dev_setup);
185 
186 	if (!dev)
187 		return NULL;
188 	dev_net_set(dev, net);
189 
190 	br = netdev_priv(dev);
191 	br->dev = dev;
192 
193 	br->stats = alloc_percpu(struct br_cpu_netstats);
194 	if (!br->stats) {
195 		free_netdev(dev);
196 		return NULL;
197 	}
198 
199 	spin_lock_init(&br->lock);
200 	INIT_LIST_HEAD(&br->port_list);
201 	spin_lock_init(&br->hash_lock);
202 
203 	br->bridge_id.prio[0] = 0x80;
204 	br->bridge_id.prio[1] = 0x00;
205 
206 	memcpy(br->group_addr, br_group_address, ETH_ALEN);
207 
208 	br->feature_mask = dev->features;
209 	br->stp_enabled = BR_NO_STP;
210 	br->designated_root = br->bridge_id;
211 	br->root_path_cost = 0;
212 	br->root_port = 0;
213 	br->bridge_max_age = br->max_age = 20 * HZ;
214 	br->bridge_hello_time = br->hello_time = 2 * HZ;
215 	br->bridge_forward_delay = br->forward_delay = 15 * HZ;
216 	br->topology_change = 0;
217 	br->topology_change_detected = 0;
218 	br->ageing_time = 300 * HZ;
219 
220 	br_netfilter_rtable_init(br);
221 
222 	br_stp_timer_init(br);
223 	br_multicast_init(br);
224 
225 	return dev;
226 }
227 
228 /* find an available port number */
229 static int find_portno(struct net_bridge *br)
230 {
231 	int index;
232 	struct net_bridge_port *p;
233 	unsigned long *inuse;
234 
235 	inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
236 			GFP_KERNEL);
237 	if (!inuse)
238 		return -ENOMEM;
239 
240 	set_bit(0, inuse);	/* zero is reserved */
241 	list_for_each_entry(p, &br->port_list, list) {
242 		set_bit(p->port_no, inuse);
243 	}
244 	index = find_first_zero_bit(inuse, BR_MAX_PORTS);
245 	kfree(inuse);
246 
247 	return (index >= BR_MAX_PORTS) ? -EXFULL : index;
248 }
249 
250 /* called with RTNL but without bridge lock */
251 static struct net_bridge_port *new_nbp(struct net_bridge *br,
252 				       struct net_device *dev)
253 {
254 	int index;
255 	struct net_bridge_port *p;
256 
257 	index = find_portno(br);
258 	if (index < 0)
259 		return ERR_PTR(index);
260 
261 	p = kzalloc(sizeof(*p), GFP_KERNEL);
262 	if (p == NULL)
263 		return ERR_PTR(-ENOMEM);
264 
265 	p->br = br;
266 	dev_hold(dev);
267 	p->dev = dev;
268 	p->path_cost = port_cost(dev);
269 	p->priority = 0x8000 >> BR_PORT_BITS;
270 	p->port_no = index;
271 	p->flags = 0;
272 	br_init_port(p);
273 	p->state = BR_STATE_DISABLED;
274 	br_stp_port_timer_init(p);
275 	br_multicast_add_port(p);
276 
277 	return p;
278 }
279 
280 static struct device_type br_type = {
281 	.name	= "bridge",
282 };
283 
284 int br_add_bridge(struct net *net, const char *name)
285 {
286 	struct net_device *dev;
287 	int ret;
288 
289 	dev = new_bridge_dev(net, name);
290 	if (!dev)
291 		return -ENOMEM;
292 
293 	rtnl_lock();
294 	if (strchr(dev->name, '%')) {
295 		ret = dev_alloc_name(dev, dev->name);
296 		if (ret < 0)
297 			goto out_free;
298 	}
299 
300 	SET_NETDEV_DEVTYPE(dev, &br_type);
301 
302 	ret = register_netdevice(dev);
303 	if (ret)
304 		goto out_free;
305 
306 	ret = br_sysfs_addbr(dev);
307 	if (ret)
308 		unregister_netdevice(dev);
309  out:
310 	rtnl_unlock();
311 	return ret;
312 
313 out_free:
314 	free_netdev(dev);
315 	goto out;
316 }
317 
318 int br_del_bridge(struct net *net, const char *name)
319 {
320 	struct net_device *dev;
321 	int ret = 0;
322 
323 	rtnl_lock();
324 	dev = __dev_get_by_name(net, name);
325 	if (dev == NULL)
326 		ret =  -ENXIO; 	/* Could not find device */
327 
328 	else if (!(dev->priv_flags & IFF_EBRIDGE)) {
329 		/* Attempt to delete non bridge device! */
330 		ret = -EPERM;
331 	}
332 
333 	else if (dev->flags & IFF_UP) {
334 		/* Not shutdown yet. */
335 		ret = -EBUSY;
336 	}
337 
338 	else
339 		del_br(netdev_priv(dev), NULL);
340 
341 	rtnl_unlock();
342 	return ret;
343 }
344 
345 /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
346 int br_min_mtu(const struct net_bridge *br)
347 {
348 	const struct net_bridge_port *p;
349 	int mtu = 0;
350 
351 	ASSERT_RTNL();
352 
353 	if (list_empty(&br->port_list))
354 		mtu = ETH_DATA_LEN;
355 	else {
356 		list_for_each_entry(p, &br->port_list, list) {
357 			if (!mtu  || p->dev->mtu < mtu)
358 				mtu = p->dev->mtu;
359 		}
360 	}
361 	return mtu;
362 }
363 
364 /*
365  * Recomputes features using slave's features
366  */
367 void br_features_recompute(struct net_bridge *br)
368 {
369 	struct net_bridge_port *p;
370 	u32 features, mask;
371 
372 	features = mask = br->feature_mask;
373 	if (list_empty(&br->port_list))
374 		goto done;
375 
376 	features &= ~NETIF_F_ONE_FOR_ALL;
377 
378 	list_for_each_entry(p, &br->port_list, list) {
379 		features = netdev_increment_features(features,
380 						     p->dev->features, mask);
381 	}
382 
383 done:
384 	br->dev->features = netdev_fix_features(br->dev, features);
385 }
386 
387 /* called with RTNL */
388 int br_add_if(struct net_bridge *br, struct net_device *dev)
389 {
390 	struct net_bridge_port *p;
391 	int err = 0;
392 
393 	/* Don't allow bridging non-ethernet like devices */
394 	if ((dev->flags & IFF_LOOPBACK) ||
395 	    dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN)
396 		return -EINVAL;
397 
398 	/* No bridging of bridges */
399 	if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit)
400 		return -ELOOP;
401 
402 	/* Device is already being bridged */
403 	if (br_port_exists(dev))
404 		return -EBUSY;
405 
406 	/* No bridging devices that dislike that (e.g. wireless) */
407 	if (dev->priv_flags & IFF_DONT_BRIDGE)
408 		return -EOPNOTSUPP;
409 
410 	p = new_nbp(br, dev);
411 	if (IS_ERR(p))
412 		return PTR_ERR(p);
413 
414 	err = dev_set_promiscuity(dev, 1);
415 	if (err)
416 		goto put_back;
417 
418 	err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
419 				   SYSFS_BRIDGE_PORT_ATTR);
420 	if (err)
421 		goto err0;
422 
423 	err = br_fdb_insert(br, p, dev->dev_addr);
424 	if (err)
425 		goto err1;
426 
427 	err = br_sysfs_addif(p);
428 	if (err)
429 		goto err2;
430 
431 	if (br_netpoll_info(br) && ((err = br_netpoll_enable(p))))
432 		goto err3;
433 
434 	err = netdev_set_master(dev, br->dev);
435 	if (err)
436 		goto err3;
437 
438 	err = netdev_rx_handler_register(dev, br_handle_frame, p);
439 	if (err)
440 		goto err4;
441 
442 	dev->priv_flags |= IFF_BRIDGE_PORT;
443 
444 	dev_disable_lro(dev);
445 
446 	list_add_rcu(&p->list, &br->port_list);
447 
448 	spin_lock_bh(&br->lock);
449 	br_stp_recalculate_bridge_id(br);
450 	br_features_recompute(br);
451 
452 	if ((dev->flags & IFF_UP) && netif_carrier_ok(dev) &&
453 	    (br->dev->flags & IFF_UP))
454 		br_stp_enable_port(p);
455 	spin_unlock_bh(&br->lock);
456 
457 	br_ifinfo_notify(RTM_NEWLINK, p);
458 
459 	dev_set_mtu(br->dev, br_min_mtu(br));
460 
461 	kobject_uevent(&p->kobj, KOBJ_ADD);
462 
463 	return 0;
464 
465 err4:
466 	netdev_set_master(dev, NULL);
467 err3:
468 	sysfs_remove_link(br->ifobj, p->dev->name);
469 err2:
470 	br_fdb_delete_by_port(br, p, 1);
471 err1:
472 	kobject_put(&p->kobj);
473 	p = NULL; /* kobject_put frees */
474 err0:
475 	dev_set_promiscuity(dev, -1);
476 put_back:
477 	dev_put(dev);
478 	kfree(p);
479 	return err;
480 }
481 
482 /* called with RTNL */
483 int br_del_if(struct net_bridge *br, struct net_device *dev)
484 {
485 	struct net_bridge_port *p;
486 
487 	p = br_port_get_rtnl(dev);
488 	if (!p || p->br != br)
489 		return -EINVAL;
490 
491 	del_nbp(p);
492 
493 	spin_lock_bh(&br->lock);
494 	br_stp_recalculate_bridge_id(br);
495 	br_features_recompute(br);
496 	spin_unlock_bh(&br->lock);
497 
498 	return 0;
499 }
500 
501 void __net_exit br_net_exit(struct net *net)
502 {
503 	struct net_device *dev;
504 	LIST_HEAD(list);
505 
506 	rtnl_lock();
507 	for_each_netdev(net, dev)
508 		if (dev->priv_flags & IFF_EBRIDGE)
509 			del_br(netdev_priv(dev), &list);
510 
511 	unregister_netdevice_many(&list);
512 	rtnl_unlock();
513 
514 }
515