br_if.c revision 1a81a2e0db5bc8fd487bc17391c65feb0d9d5f94 
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/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>
25#include <net/sock.h>
26#include <linux/if_vlan.h>
27
28#include "br_private.h"
29
30/*
31 * Determine initial path cost based on speed.
32 * using recommendations from 802.1d standard
33 *
34 * Since driver might sleep need to not be holding any locks.
35 */
36static int port_cost(struct net_device *dev)
37{
38	struct ethtool_cmd ecmd;
39
40	if (!__ethtool_get_settings(dev, &ecmd)) {
41		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;
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 transitions. */
65void 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 (!(p->flags & BR_ADMIN_COST) &&
71	    netif_running(dev) && netif_oper_up(dev))
72		p->path_cost = port_cost(dev);
73
74	if (!netif_running(br->dev))
75		return;
76
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);
81	} else {
82		if (p->state != BR_STATE_DISABLED)
83			br_stp_disable_port(p);
84	}
85	spin_unlock_bh(&br->lock);
86}
87
88static void release_nbp(struct kobject *kobj)
89{
90	struct net_bridge_port *p
91		= container_of(kobj, struct net_bridge_port, kobj);
92	kfree(p);
93}
94
95static struct kobj_type brport_ktype = {
96#ifdef CONFIG_SYSFS
97	.sysfs_ops = &brport_sysfs_ops,
98#endif
99	.release = release_nbp,
100};
101
102static void destroy_nbp(struct net_bridge_port *p)
103{
104	struct net_device *dev = p->dev;
105
106	p->br = NULL;
107	p->dev = NULL;
108	dev_put(dev);
109
110	kobject_put(&p->kobj);
111}
112
113static void destroy_nbp_rcu(struct rcu_head *head)
114{
115	struct net_bridge_port *p =
116			container_of(head, struct net_bridge_port, rcu);
117	destroy_nbp(p);
118}
119
120/* Delete port(interface) from bridge is done in two steps.
121 * via RCU. First step, marks device as down. That deletes
122 * all the timers and stops new packets from flowing through.
123 *
124 * Final cleanup doesn't occur until after all CPU's finished
125 * processing packets.
126 *
127 * Protected from multiple admin operations by RTNL mutex
128 */
129static void del_nbp(struct net_bridge_port *p)
130{
131	struct net_bridge *br = p->br;
132	struct net_device *dev = p->dev;
133
134	sysfs_remove_link(br->ifobj, p->dev->name);
135
136	dev_set_promiscuity(dev, -1);
137
138	spin_lock_bh(&br->lock);
139	br_stp_disable_port(p);
140	spin_unlock_bh(&br->lock);
141
142	br_ifinfo_notify(RTM_DELLINK, p);
143
144	nbp_vlan_flush(p);
145	br_fdb_delete_by_port(br, p, 1);
146
147	list_del_rcu(&p->list);
148
149	dev->priv_flags &= ~IFF_BRIDGE_PORT;
150
151	netdev_rx_handler_unregister(dev);
152
153	netdev_upper_dev_unlink(dev, br->dev);
154
155	br_multicast_del_port(p);
156
157	kobject_uevent(&p->kobj, KOBJ_REMOVE);
158	kobject_del(&p->kobj);
159
160	br_netpoll_disable(p);
161
162	call_rcu(&p->rcu, destroy_nbp_rcu);
163}
164
165/* Delete bridge device */
166void br_dev_delete(struct net_device *dev, struct list_head *head)
167{
168	struct net_bridge *br = netdev_priv(dev);
169	struct net_bridge_port *p, *n;
170
171	list_for_each_entry_safe(p, n, &br->port_list, list) {
172		del_nbp(p);
173	}
174
175	br_fdb_delete_by_port(br, NULL, 1);
176
177	br_vlan_flush(br);
178	del_timer_sync(&br->gc_timer);
179
180	br_sysfs_delbr(br->dev);
181	unregister_netdevice_queue(br->dev, head);
182}
183
184/* find an available port number */
185static int find_portno(struct net_bridge *br)
186{
187	int index;
188	struct net_bridge_port *p;
189	unsigned long *inuse;
190
191	inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
192			GFP_KERNEL);
193	if (!inuse)
194		return -ENOMEM;
195
196	set_bit(0, inuse);	/* zero is reserved */
197	list_for_each_entry(p, &br->port_list, list) {
198		set_bit(p->port_no, inuse);
199	}
200	index = find_first_zero_bit(inuse, BR_MAX_PORTS);
201	kfree(inuse);
202
203	return (index >= BR_MAX_PORTS) ? -EXFULL : index;
204}
205
206/* called with RTNL but without bridge lock */
207static struct net_bridge_port *new_nbp(struct net_bridge *br,
208				       struct net_device *dev)
209{
210	int index;
211	struct net_bridge_port *p;
212
213	index = find_portno(br);
214	if (index < 0)
215		return ERR_PTR(index);
216
217	p = kzalloc(sizeof(*p), GFP_KERNEL);
218	if (p == NULL)
219		return ERR_PTR(-ENOMEM);
220
221	p->br = br;
222	dev_hold(dev);
223	p->dev = dev;
224	p->path_cost = port_cost(dev);
225	p->priority = 0x8000 >> BR_PORT_BITS;
226	p->port_no = index;
227	p->flags = BR_LEARNING | BR_FLOOD;
228	br_init_port(p);
229	p->state = BR_STATE_DISABLED;
230	br_stp_port_timer_init(p);
231	br_multicast_add_port(p);
232
233	return p;
234}
235
236int br_add_bridge(struct net *net, const char *name)
237{
238	struct net_device *dev;
239	int res;
240
241	dev = alloc_netdev(sizeof(struct net_bridge), name,
242			   br_dev_setup);
243
244	if (!dev)
245		return -ENOMEM;
246
247	dev_net_set(dev, net);
248	dev->rtnl_link_ops = &br_link_ops;
249
250	res = register_netdev(dev);
251	if (res)
252		free_netdev(dev);
253	return res;
254}
255
256int br_del_bridge(struct net *net, const char *name)
257{
258	struct net_device *dev;
259	int ret = 0;
260
261	rtnl_lock();
262	dev = __dev_get_by_name(net, name);
263	if (dev == NULL)
264		ret =  -ENXIO; 	/* Could not find device */
265
266	else if (!(dev->priv_flags & IFF_EBRIDGE)) {
267		/* Attempt to delete non bridge device! */
268		ret = -EPERM;
269	}
270
271	else if (dev->flags & IFF_UP) {
272		/* Not shutdown yet. */
273		ret = -EBUSY;
274	}
275
276	else
277		br_dev_delete(dev, NULL);
278
279	rtnl_unlock();
280	return ret;
281}
282
283/* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
284int br_min_mtu(const struct net_bridge *br)
285{
286	const struct net_bridge_port *p;
287	int mtu = 0;
288
289	ASSERT_RTNL();
290
291	if (list_empty(&br->port_list))
292		mtu = ETH_DATA_LEN;
293	else {
294		list_for_each_entry(p, &br->port_list, list) {
295			if (!mtu  || p->dev->mtu < mtu)
296				mtu = p->dev->mtu;
297		}
298	}
299	return mtu;
300}
301
302/*
303 * Recomputes features using slave's features
304 */
305netdev_features_t br_features_recompute(struct net_bridge *br,
306	netdev_features_t features)
307{
308	struct net_bridge_port *p;
309	netdev_features_t mask;
310
311	if (list_empty(&br->port_list))
312		return features;
313
314	mask = features;
315	features &= ~NETIF_F_ONE_FOR_ALL;
316
317	list_for_each_entry(p, &br->port_list, list) {
318		features = netdev_increment_features(features,
319						     p->dev->features, mask);
320	}
321
322	return features;
323}
324
325/* called with RTNL */
326int br_add_if(struct net_bridge *br, struct net_device *dev)
327{
328	struct net_bridge_port *p;
329	int err = 0;
330	bool changed_addr;
331
332	/* Don't allow bridging non-ethernet like devices */
333	if ((dev->flags & IFF_LOOPBACK) ||
334	    dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN ||
335	    !is_valid_ether_addr(dev->dev_addr))
336		return -EINVAL;
337
338	/* No bridging of bridges */
339	if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit)
340		return -ELOOP;
341
342	/* Device is already being bridged */
343	if (br_port_exists(dev))
344		return -EBUSY;
345
346	/* No bridging devices that dislike that (e.g. wireless) */
347	if (dev->priv_flags & IFF_DONT_BRIDGE)
348		return -EOPNOTSUPP;
349
350	p = new_nbp(br, dev);
351	if (IS_ERR(p))
352		return PTR_ERR(p);
353
354	call_netdevice_notifiers(NETDEV_JOIN, dev);
355
356	err = dev_set_promiscuity(dev, 1);
357	if (err)
358		goto put_back;
359
360	err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
361				   SYSFS_BRIDGE_PORT_ATTR);
362	if (err)
363		goto err1;
364
365	err = br_sysfs_addif(p);
366	if (err)
367		goto err2;
368
369	err = br_netpoll_enable(p, GFP_KERNEL);
370	if (err)
371		goto err3;
372
373	err = netdev_master_upper_dev_link(dev, br->dev);
374	if (err)
375		goto err4;
376
377	err = netdev_rx_handler_register(dev, br_handle_frame, p);
378	if (err)
379		goto err5;
380
381	dev->priv_flags |= IFF_BRIDGE_PORT;
382
383	dev_disable_lro(dev);
384
385	list_add_rcu(&p->list, &br->port_list);
386
387	netdev_update_features(br->dev);
388
389	if (br->dev->needed_headroom < dev->needed_headroom)
390		br->dev->needed_headroom = dev->needed_headroom;
391
392	spin_lock_bh(&br->lock);
393	changed_addr = br_stp_recalculate_bridge_id(br);
394
395	if (netif_running(dev) && netif_oper_up(dev) &&
396	    (br->dev->flags & IFF_UP))
397		br_stp_enable_port(p);
398	spin_unlock_bh(&br->lock);
399
400	br_ifinfo_notify(RTM_NEWLINK, p);
401
402	if (changed_addr)
403		call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
404
405	dev_set_mtu(br->dev, br_min_mtu(br));
406
407	if (br_fdb_insert(br, p, dev->dev_addr, 0))
408		netdev_err(dev, "failed insert local address bridge forwarding table\n");
409
410	kobject_uevent(&p->kobj, KOBJ_ADD);
411
412	return 0;
413
414err5:
415	netdev_upper_dev_unlink(dev, br->dev);
416err4:
417	br_netpoll_disable(p);
418err3:
419	sysfs_remove_link(br->ifobj, p->dev->name);
420err2:
421	kobject_put(&p->kobj);
422	p = NULL; /* kobject_put frees */
423err1:
424	dev_set_promiscuity(dev, -1);
425put_back:
426	dev_put(dev);
427	kfree(p);
428	return err;
429}
430
431/* called with RTNL */
432int br_del_if(struct net_bridge *br, struct net_device *dev)
433{
434	struct net_bridge_port *p;
435	bool changed_addr;
436
437	p = br_port_get_rtnl(dev);
438	if (!p || p->br != br)
439		return -EINVAL;
440
441	/* Since more than one interface can be attached to a bridge,
442	 * there still maybe an alternate path for netconsole to use;
443	 * therefore there is no reason for a NETDEV_RELEASE event.
444	 */
445	del_nbp(p);
446
447	spin_lock_bh(&br->lock);
448	changed_addr = br_stp_recalculate_bridge_id(br);
449	spin_unlock_bh(&br->lock);
450
451	if (changed_addr)
452		call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
453
454	netdev_update_features(br->dev);
455
456	return 0;
457}
458
459void __net_exit br_net_exit(struct net *net)
460{
461	struct net_device *dev;
462	LIST_HEAD(list);
463
464	rtnl_lock();
465	for_each_netdev(net, dev)
466		if (dev->priv_flags & IFF_EBRIDGE)
467			br_dev_delete(dev, &list);
468
469	unregister_netdevice_many(&list);
470	rtnl_unlock();
471
472}
473