1/*
2 *	Userspace interface
3 *	Linux ethernet bridge
4 *
5 *	Authors:
6 *	Lennert Buytenhek		<buytenh@gnu.org>
7 *
8 *	$Id: br_if.c,v 1.4.2.1 2010/11/05 06:20:14 Exp $
9 *
10 *	This program is free software; you can redistribute it and/or
11 *	modify it under the terms of the GNU General Public License
12 *	as published by the Free Software Foundation; either version
13 *	2 of the License, or (at your option) any later version.
14 */
15
16#include <linux/kernel.h>
17#include <linux/netdevice.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 <net/sock.h>
25
26#include "br_private.h"
27
28#ifdef HNDCTF
29#include <ctf/hndctf.h>
30#endif /* HNDCTF */
31
32/*
33 * Determine initial path cost based on speed.
34 * using recommendations from 802.1d standard
35 *
36 * Need to simulate user ioctl because not all device's that support
37 * ethtool, use ethtool_ops.  Also, since driver might sleep need to
38 * not be holding any locks.
39 */
40static int port_cost(struct net_device *dev)
41{
42	struct ethtool_cmd ecmd = { ETHTOOL_GSET };
43	struct ifreq ifr;
44	mm_segment_t old_fs;
45	int err;
46
47	strncpy(ifr.ifr_name, dev->name, IFNAMSIZ);
48	ifr.ifr_data = (void __user *) &ecmd;
49
50	old_fs = get_fs();
51	set_fs(KERNEL_DS);
52	err = dev_ethtool(&ifr);
53	set_fs(old_fs);
54
55	if (!err) {
56		switch(ecmd.speed) {
57		case SPEED_100:
58			return 19;
59		case SPEED_1000:
60			return 4;
61		case SPEED_10000:
62			return 2;
63		case SPEED_10:
64			return 100;
65		}
66	}
67
68	/* Old silly heuristics based on name */
69	if (!strncmp(dev->name, "lec", 3))
70		return 7;
71
72	if (!strncmp(dev->name, "plip", 4))
73		return 2500;
74
75	return 100;	/* assume old 10Mbps */
76}
77
78
79/*
80 * Check for port carrier transistions.
81 * Called from work queue to allow for calling functions that
82 * might sleep (such as speed check), and to debounce.
83 */
84void br_port_carrier_check(struct net_bridge_port *p)
85{
86	struct net_device *dev = p->dev;
87	struct net_bridge *br = p->br;
88
89	if (netif_carrier_ok(dev))
90		p->path_cost = port_cost(dev);
91
92	if (netif_running(br->dev)) {
93		spin_lock_bh(&br->lock);
94		if (netif_carrier_ok(dev)) {
95			if (p->state == BR_STATE_DISABLED)
96				br_stp_enable_port(p);
97		} else {
98			if (p->state != BR_STATE_DISABLED)
99				br_stp_disable_port(p);
100		}
101		spin_unlock_bh(&br->lock);
102	}
103}
104
105static void release_nbp(struct kobject *kobj)
106{
107	struct net_bridge_port *p
108		= container_of(kobj, struct net_bridge_port, kobj);
109	kfree(p);
110}
111
112static struct kobj_type brport_ktype = {
113#ifdef CONFIG_SYSFS
114	.sysfs_ops = &brport_sysfs_ops,
115#endif
116	.release = release_nbp,
117};
118
119static void destroy_nbp(struct net_bridge_port *p)
120{
121	struct net_device *dev = p->dev;
122
123	p->br = NULL;
124	p->dev = NULL;
125	dev_put(dev);
126
127	kobject_put(&p->kobj);
128}
129
130static void destroy_nbp_rcu(struct rcu_head *head)
131{
132	struct net_bridge_port *p =
133			container_of(head, struct net_bridge_port, rcu);
134	destroy_nbp(p);
135}
136
137/* Delete port(interface) from bridge is done in two steps.
138 * via RCU. First step, marks device as down. That deletes
139 * all the timers and stops new packets from flowing through.
140 *
141 * Final cleanup doesn't occur until after all CPU's finished
142 * processing packets.
143 *
144 * Protected from multiple admin operations by RTNL mutex
145 */
146static void del_nbp(struct net_bridge_port *p)
147{
148	struct net_bridge *br = p->br;
149	struct net_device *dev = p->dev;
150
151	sysfs_remove_link(&br->ifobj, dev->name);
152
153	dev_set_promiscuity(dev, -1);
154
155	spin_lock_bh(&br->lock);
156	br_stp_disable_port(p);
157	spin_unlock_bh(&br->lock);
158
159	br_ifinfo_notify(RTM_DELLINK, p);
160
161	br_fdb_delete_by_port(br, p, 1);
162
163	list_del_rcu(&p->list);
164
165	rcu_assign_pointer(dev->br_port, NULL);
166
167	kobject_uevent(&p->kobj, KOBJ_REMOVE);
168	kobject_del(&p->kobj);
169
170	call_rcu(&p->rcu, destroy_nbp_rcu);
171}
172
173/* called with RTNL */
174static void del_br(struct net_bridge *br)
175{
176	struct net_bridge_port *p, *n;
177
178	list_for_each_entry_safe(p, n, &br->port_list, list) {
179		del_nbp(p);
180	}
181
182	del_timer_sync(&br->gc_timer);
183
184	br_sysfs_delbr(br->dev);
185	unregister_netdevice(br->dev);
186}
187
188static struct net_device *new_bridge_dev(const char *name)
189{
190	struct net_bridge *br;
191	struct net_device *dev;
192
193	dev = alloc_netdev(sizeof(struct net_bridge), name,
194			   br_dev_setup);
195
196	if (!dev)
197		return NULL;
198
199	br = netdev_priv(dev);
200	br->dev = dev;
201
202	spin_lock_init(&br->lock);
203	INIT_LIST_HEAD(&br->port_list);
204	spin_lock_init(&br->hash_lock);
205
206	br->bridge_id.prio[0] = 0x80;
207	br->bridge_id.prio[1] = 0x00;
208
209	memcpy(br->group_addr, br_group_address, ETH_ALEN);
210
211	br->feature_mask = dev->features;
212	br->stp_enabled = BR_NO_STP;
213	br->designated_root = br->bridge_id;
214	br->root_path_cost = 0;
215	br->root_port = 0;
216	br->bridge_max_age = br->max_age = 20 * HZ;
217	br->bridge_hello_time = br->hello_time = 2 * HZ;
218	br->bridge_forward_delay = br->forward_delay = 15 * HZ;
219	br->topology_change = 0;
220	br->topology_change_detected = 0;
221	br->ageing_time = 300 * HZ;
222	INIT_LIST_HEAD(&br->age_list);
223
224#ifdef CONFIG_INET_GSO
225	br->feature_mask |= NETIF_F_GSO;
226#endif /* CONFIG_INET_GSO */
227	br_stp_timer_init(br);
228
229	return dev;
230}
231
232/* find an available port number */
233static int find_portno(struct net_bridge *br)
234{
235	int index;
236	struct net_bridge_port *p;
237	unsigned long *inuse;
238
239	inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
240			GFP_KERNEL);
241	if (!inuse)
242		return -ENOMEM;
243
244	set_bit(0, inuse);	/* zero is reserved */
245	list_for_each_entry(p, &br->port_list, list) {
246		set_bit(p->port_no, inuse);
247	}
248	index = find_first_zero_bit(inuse, BR_MAX_PORTS);
249	kfree(inuse);
250
251	return (index >= BR_MAX_PORTS) ? -EXFULL : index;
252}
253
254/* called with RTNL but without bridge lock */
255static struct net_bridge_port *new_nbp(struct net_bridge *br,
256				       struct net_device *dev)
257{
258	int index;
259	struct net_bridge_port *p;
260
261	index = find_portno(br);
262	if (index < 0)
263		return ERR_PTR(index);
264
265	p = kzalloc(sizeof(*p), GFP_KERNEL);
266	if (p == NULL)
267		return ERR_PTR(-ENOMEM);
268
269	p->br = br;
270	dev_hold(dev);
271	p->dev = dev;
272	p->path_cost = port_cost(dev);
273	p->priority = 0x8000 >> BR_PORT_BITS;
274	p->port_no = index;
275	br_init_port(p);
276	p->state = BR_STATE_DISABLED;
277	br_stp_port_timer_init(p);
278
279	kobject_init(&p->kobj);
280	kobject_set_name(&p->kobj, SYSFS_BRIDGE_PORT_ATTR);
281	p->kobj.ktype = &brport_ktype;
282	p->kobj.parent = &(dev->dev.kobj);
283	p->kobj.kset = NULL;
284
285	return p;
286}
287
288int br_add_bridge(const char *name)
289{
290	struct net_device *dev;
291	int ret;
292
293	dev = new_bridge_dev(name);
294	if (!dev)
295		return -ENOMEM;
296
297#ifdef CONFIG_INET_GSO
298	dev->features |= NETIF_F_GSO;
299#endif /* CONFIG_INET_GSO */
300
301	rtnl_lock();
302	if (strchr(dev->name, '%')) {
303		ret = dev_alloc_name(dev, dev->name);
304		if (ret < 0) {
305			free_netdev(dev);
306			goto out;
307		}
308	}
309
310	ret = register_netdevice(dev);
311	if (ret)
312		goto out;
313
314#ifdef HNDCTF
315	if ((ctf_dev_register(kcih, dev, TRUE) != BCME_OK) ||
316	    (ctf_enable(kcih, dev, TRUE) != BCME_OK)) {
317		ctf_dev_unregister(kcih, dev);
318		unregister_netdevice(dev);
319		ret = -ENXIO;
320		goto out;
321	}
322#endif /* HNDCTF */
323
324	ret = br_sysfs_addbr(dev);
325	if (ret)
326		unregister_netdevice(dev);
327 out:
328	rtnl_unlock();
329	return ret;
330}
331
332int br_del_bridge(const char *name)
333{
334	struct net_device *dev;
335	int ret = 0;
336
337	rtnl_lock();
338	dev = __dev_get_by_name(name);
339	if (dev == NULL)
340		ret =  -ENXIO; 	/* Could not find device */
341
342	else if (!(dev->priv_flags & IFF_EBRIDGE)) {
343		/* Attempt to delete non bridge device! */
344		ret = -EPERM;
345	}
346
347	else if (dev->flags & IFF_UP) {
348		/* Not shutdown yet. */
349		ret = -EBUSY;
350	}
351
352	else {
353#ifdef HNDCTF
354		ctf_dev_unregister(kcih, dev);
355#endif /* HNDCTF */
356		del_br(netdev_priv(dev));
357	}
358
359	rtnl_unlock();
360	return ret;
361}
362
363/* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
364int br_min_mtu(const struct net_bridge *br)
365{
366	const struct net_bridge_port *p;
367	int mtu = 0;
368
369	ASSERT_RTNL();
370
371	if (list_empty(&br->port_list))
372		mtu = ETH_DATA_LEN;
373	else {
374		list_for_each_entry(p, &br->port_list, list) {
375			if (!mtu  || p->dev->mtu < mtu)
376				mtu = p->dev->mtu;
377		}
378	}
379	return mtu;
380}
381
382/*
383 * Recomputes features using slave's features
384 */
385void br_features_recompute(struct net_bridge *br)
386{
387	struct net_bridge_port *p;
388	unsigned long features, checksum;
389
390	checksum = br->feature_mask & NETIF_F_ALL_CSUM ? NETIF_F_NO_CSUM : 0;
391	features = br->feature_mask & ~NETIF_F_ALL_CSUM;
392
393	list_for_each_entry(p, &br->port_list, list) {
394		unsigned long feature = p->dev->features;
395
396		if (checksum & NETIF_F_NO_CSUM && !(feature & NETIF_F_NO_CSUM))
397			checksum ^= NETIF_F_NO_CSUM | NETIF_F_HW_CSUM;
398		if (checksum & NETIF_F_HW_CSUM && !(feature & NETIF_F_HW_CSUM))
399			checksum ^= NETIF_F_HW_CSUM | NETIF_F_IP_CSUM;
400		if (!(feature & NETIF_F_IP_CSUM))
401			checksum = 0;
402
403		if (feature & NETIF_F_GSO)
404			feature |= NETIF_F_GSO_SOFTWARE;
405		feature |= NETIF_F_GSO;
406
407		features &= feature;
408	}
409
410	if (!(checksum & NETIF_F_ALL_CSUM))
411		features &= ~NETIF_F_SG;
412	if (!(features & NETIF_F_SG))
413		features &= ~NETIF_F_GSO_MASK;
414
415	br->dev->features = features | checksum | NETIF_F_LLTX |
416			    NETIF_F_GSO_ROBUST;
417}
418
419/* called with RTNL */
420int br_add_if(struct net_bridge *br, struct net_device *dev)
421{
422	struct net_bridge_port *p;
423	int err = 0;
424
425	if (dev->flags & IFF_LOOPBACK || dev->type != ARPHRD_ETHER)
426		return -EINVAL;
427
428	if (dev->hard_start_xmit == br_dev_xmit)
429		return -ELOOP;
430
431	if (dev->br_port != NULL)
432		return -EBUSY;
433
434	p = new_nbp(br, dev);
435	if (IS_ERR(p))
436		return PTR_ERR(p);
437
438	err = kobject_add(&p->kobj);
439	if (err)
440		goto err0;
441
442	err = br_fdb_insert(br, p, dev->dev_addr);
443	if (err)
444		goto err1;
445
446	err = br_sysfs_addif(p);
447	if (err)
448		goto err2;
449
450	rcu_assign_pointer(dev->br_port, p);
451	dev_set_promiscuity(dev, 1);
452
453	list_add_rcu(&p->list, &br->port_list);
454
455	spin_lock_bh(&br->lock);
456	br_stp_recalculate_bridge_id(br);
457	br_features_recompute(br);
458
459	if ((dev->flags & IFF_UP) && netif_carrier_ok(dev) &&
460	    (br->dev->flags & IFF_UP))
461		br_stp_enable_port(p);
462	spin_unlock_bh(&br->lock);
463
464	br_ifinfo_notify(RTM_NEWLINK, p);
465
466	dev_set_mtu(br->dev, br_min_mtu(br));
467
468	kobject_uevent(&p->kobj, KOBJ_ADD);
469
470	return 0;
471err2:
472	br_fdb_delete_by_port(br, p, 1);
473err1:
474	kobject_del(&p->kobj);
475err0:
476	kobject_put(&p->kobj);
477	return err;
478}
479
480/* called with RTNL */
481int br_del_if(struct net_bridge *br, struct net_device *dev)
482{
483	struct net_bridge_port *p = dev->br_port;
484
485	if (!p || p->br != br)
486		return -EINVAL;
487
488	del_nbp(p);
489
490	spin_lock_bh(&br->lock);
491	br_stp_recalculate_bridge_id(br);
492	br_features_recompute(br);
493	spin_unlock_bh(&br->lock);
494
495	return 0;
496}
497
498void __exit br_cleanup_bridges(void)
499{
500	struct net_device *dev, *nxt;
501
502	rtnl_lock();
503	for_each_netdev_safe(dev, nxt)
504		if (dev->priv_flags & IFF_EBRIDGE)
505			del_br(dev->priv);
506	rtnl_unlock();
507
508}
509