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#include <net/switchdev.h>
28
29#include "br_private.h"
30
31/*
32 * Determine initial path cost based on speed.
33 * using recommendations from 802.1d standard
34 *
35 * Since driver might sleep need to not be holding any locks.
36 */
37static int port_cost(struct net_device *dev)
38{
39	struct ethtool_cmd ecmd;
40
41	if (!__ethtool_get_settings(dev, &ecmd)) {
42		switch (ethtool_cmd_speed(&ecmd)) {
43		case SPEED_10000:
44			return 2;
45		case SPEED_1000:
46			return 4;
47		case SPEED_100:
48			return 19;
49		case SPEED_10:
50			return 100;
51		}
52	}
53
54	/* Old silly heuristics based on name */
55	if (!strncmp(dev->name, "lec", 3))
56		return 7;
57
58	if (!strncmp(dev->name, "plip", 4))
59		return 2500;
60
61	return 100;	/* assume old 10Mbps */
62}
63
64
65/* Check for port carrier transitions. */
66void br_port_carrier_check(struct net_bridge_port *p)
67{
68	struct net_device *dev = p->dev;
69	struct net_bridge *br = p->br;
70
71	if (!(p->flags & BR_ADMIN_COST) &&
72	    netif_running(dev) && netif_oper_up(dev))
73		p->path_cost = port_cost(dev);
74
75	if (!netif_running(br->dev))
76		return;
77
78	spin_lock_bh(&br->lock);
79	if (netif_running(dev) && netif_oper_up(dev)) {
80		if (p->state == BR_STATE_DISABLED)
81			br_stp_enable_port(p);
82	} else {
83		if (p->state != BR_STATE_DISABLED)
84			br_stp_disable_port(p);
85	}
86	spin_unlock_bh(&br->lock);
87}
88
89static void br_port_set_promisc(struct net_bridge_port *p)
90{
91	int err = 0;
92
93	if (br_promisc_port(p))
94		return;
95
96	err = dev_set_promiscuity(p->dev, 1);
97	if (err)
98		return;
99
100	br_fdb_unsync_static(p->br, p);
101	p->flags |= BR_PROMISC;
102}
103
104static void br_port_clear_promisc(struct net_bridge_port *p)
105{
106	int err;
107
108	/* Check if the port is already non-promisc or if it doesn't
109	 * support UNICAST filtering.  Without unicast filtering support
110	 * we'll end up re-enabling promisc mode anyway, so just check for
111	 * it here.
112	 */
113	if (!br_promisc_port(p) || !(p->dev->priv_flags & IFF_UNICAST_FLT))
114		return;
115
116	/* Since we'll be clearing the promisc mode, program the port
117	 * first so that we don't have interruption in traffic.
118	 */
119	err = br_fdb_sync_static(p->br, p);
120	if (err)
121		return;
122
123	dev_set_promiscuity(p->dev, -1);
124	p->flags &= ~BR_PROMISC;
125}
126
127/* When a port is added or removed or when certain port flags
128 * change, this function is called to automatically manage
129 * promiscuity setting of all the bridge ports.  We are always called
130 * under RTNL so can skip using rcu primitives.
131 */
132void br_manage_promisc(struct net_bridge *br)
133{
134	struct net_bridge_port *p;
135	bool set_all = false;
136
137	/* If vlan filtering is disabled or bridge interface is placed
138	 * into promiscuous mode, place all ports in promiscuous mode.
139	 */
140	if ((br->dev->flags & IFF_PROMISC) || !br_vlan_enabled(br))
141		set_all = true;
142
143	list_for_each_entry(p, &br->port_list, list) {
144		if (set_all) {
145			br_port_set_promisc(p);
146		} else {
147			/* If the number of auto-ports is <= 1, then all other
148			 * ports will have their output configuration
149			 * statically specified through fdbs.  Since ingress
150			 * on the auto-port becomes forwarding/egress to other
151			 * ports and egress configuration is statically known,
152			 * we can say that ingress configuration of the
153			 * auto-port is also statically known.
154			 * This lets us disable promiscuous mode and write
155			 * this config to hw.
156			 */
157			if (br->auto_cnt == 0 ||
158			    (br->auto_cnt == 1 && br_auto_port(p)))
159				br_port_clear_promisc(p);
160			else
161				br_port_set_promisc(p);
162		}
163	}
164}
165
166static void nbp_update_port_count(struct net_bridge *br)
167{
168	struct net_bridge_port *p;
169	u32 cnt = 0;
170
171	list_for_each_entry(p, &br->port_list, list) {
172		if (br_auto_port(p))
173			cnt++;
174	}
175	if (br->auto_cnt != cnt) {
176		br->auto_cnt = cnt;
177		br_manage_promisc(br);
178	}
179}
180
181static void nbp_delete_promisc(struct net_bridge_port *p)
182{
183	/* If port is currently promiscuous, unset promiscuity.
184	 * Otherwise, it is a static port so remove all addresses
185	 * from it.
186	 */
187	dev_set_allmulti(p->dev, -1);
188	if (br_promisc_port(p))
189		dev_set_promiscuity(p->dev, -1);
190	else
191		br_fdb_unsync_static(p->br, p);
192}
193
194static void release_nbp(struct kobject *kobj)
195{
196	struct net_bridge_port *p
197		= container_of(kobj, struct net_bridge_port, kobj);
198	kfree(p);
199}
200
201static struct kobj_type brport_ktype = {
202#ifdef CONFIG_SYSFS
203	.sysfs_ops = &brport_sysfs_ops,
204#endif
205	.release = release_nbp,
206};
207
208static void destroy_nbp(struct net_bridge_port *p)
209{
210	struct net_device *dev = p->dev;
211
212	p->br = NULL;
213	p->dev = NULL;
214	dev_put(dev);
215
216	kobject_put(&p->kobj);
217}
218
219static void destroy_nbp_rcu(struct rcu_head *head)
220{
221	struct net_bridge_port *p =
222			container_of(head, struct net_bridge_port, rcu);
223	destroy_nbp(p);
224}
225
226/* Delete port(interface) from bridge is done in two steps.
227 * via RCU. First step, marks device as down. That deletes
228 * all the timers and stops new packets from flowing through.
229 *
230 * Final cleanup doesn't occur until after all CPU's finished
231 * processing packets.
232 *
233 * Protected from multiple admin operations by RTNL mutex
234 */
235static void del_nbp(struct net_bridge_port *p)
236{
237	struct net_bridge *br = p->br;
238	struct net_device *dev = p->dev;
239
240	sysfs_remove_link(br->ifobj, p->dev->name);
241
242	nbp_delete_promisc(p);
243
244	spin_lock_bh(&br->lock);
245	br_stp_disable_port(p);
246	spin_unlock_bh(&br->lock);
247
248	br_ifinfo_notify(RTM_DELLINK, p);
249
250	list_del_rcu(&p->list);
251
252	nbp_vlan_flush(p);
253	br_fdb_delete_by_port(br, p, 0, 1);
254	switchdev_deferred_process();
255
256	nbp_update_port_count(br);
257
258	netdev_upper_dev_unlink(dev, br->dev);
259
260	dev->priv_flags &= ~IFF_BRIDGE_PORT;
261
262	netdev_rx_handler_unregister(dev);
263
264	br_multicast_del_port(p);
265
266	kobject_uevent(&p->kobj, KOBJ_REMOVE);
267	kobject_del(&p->kobj);
268
269	br_netpoll_disable(p);
270
271	call_rcu(&p->rcu, destroy_nbp_rcu);
272}
273
274/* Delete bridge device */
275void br_dev_delete(struct net_device *dev, struct list_head *head)
276{
277	struct net_bridge *br = netdev_priv(dev);
278	struct net_bridge_port *p, *n;
279
280	list_for_each_entry_safe(p, n, &br->port_list, list) {
281		del_nbp(p);
282	}
283
284	br_fdb_delete_by_port(br, NULL, 0, 1);
285
286	br_vlan_flush(br);
287	br_multicast_dev_del(br);
288	del_timer_sync(&br->gc_timer);
289
290	br_sysfs_delbr(br->dev);
291	unregister_netdevice_queue(br->dev, head);
292}
293
294/* find an available port number */
295static int find_portno(struct net_bridge *br)
296{
297	int index;
298	struct net_bridge_port *p;
299	unsigned long *inuse;
300
301	inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
302			GFP_KERNEL);
303	if (!inuse)
304		return -ENOMEM;
305
306	set_bit(0, inuse);	/* zero is reserved */
307	list_for_each_entry(p, &br->port_list, list) {
308		set_bit(p->port_no, inuse);
309	}
310	index = find_first_zero_bit(inuse, BR_MAX_PORTS);
311	kfree(inuse);
312
313	return (index >= BR_MAX_PORTS) ? -EXFULL : index;
314}
315
316/* called with RTNL but without bridge lock */
317static struct net_bridge_port *new_nbp(struct net_bridge *br,
318				       struct net_device *dev)
319{
320	int index;
321	struct net_bridge_port *p;
322
323	index = find_portno(br);
324	if (index < 0)
325		return ERR_PTR(index);
326
327	p = kzalloc(sizeof(*p), GFP_KERNEL);
328	if (p == NULL)
329		return ERR_PTR(-ENOMEM);
330
331	p->br = br;
332	dev_hold(dev);
333	p->dev = dev;
334	p->path_cost = port_cost(dev);
335	p->priority = 0x8000 >> BR_PORT_BITS;
336	p->port_no = index;
337	p->flags = BR_LEARNING | BR_FLOOD;
338	br_init_port(p);
339	br_set_state(p, BR_STATE_DISABLED);
340	br_stp_port_timer_init(p);
341	br_multicast_add_port(p);
342
343	return p;
344}
345
346int br_add_bridge(struct net *net, const char *name)
347{
348	struct net_device *dev;
349	int res;
350
351	dev = alloc_netdev(sizeof(struct net_bridge), name, NET_NAME_UNKNOWN,
352			   br_dev_setup);
353
354	if (!dev)
355		return -ENOMEM;
356
357	dev_net_set(dev, net);
358	dev->rtnl_link_ops = &br_link_ops;
359
360	res = register_netdev(dev);
361	if (res)
362		free_netdev(dev);
363	return res;
364}
365
366int br_del_bridge(struct net *net, const char *name)
367{
368	struct net_device *dev;
369	int ret = 0;
370
371	rtnl_lock();
372	dev = __dev_get_by_name(net, name);
373	if (dev == NULL)
374		ret =  -ENXIO; 	/* Could not find device */
375
376	else if (!(dev->priv_flags & IFF_EBRIDGE)) {
377		/* Attempt to delete non bridge device! */
378		ret = -EPERM;
379	}
380
381	else if (dev->flags & IFF_UP) {
382		/* Not shutdown yet. */
383		ret = -EBUSY;
384	}
385
386	else
387		br_dev_delete(dev, NULL);
388
389	rtnl_unlock();
390	return ret;
391}
392
393/* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
394int br_min_mtu(const struct net_bridge *br)
395{
396	const struct net_bridge_port *p;
397	int mtu = 0;
398
399	ASSERT_RTNL();
400
401	if (list_empty(&br->port_list))
402		mtu = ETH_DATA_LEN;
403	else {
404		list_for_each_entry(p, &br->port_list, list) {
405			if (!mtu  || p->dev->mtu < mtu)
406				mtu = p->dev->mtu;
407		}
408	}
409	return mtu;
410}
411
412/*
413 * Recomputes features using slave's features
414 */
415netdev_features_t br_features_recompute(struct net_bridge *br,
416	netdev_features_t features)
417{
418	struct net_bridge_port *p;
419	netdev_features_t mask;
420
421	if (list_empty(&br->port_list))
422		return features;
423
424	mask = features;
425	features &= ~NETIF_F_ONE_FOR_ALL;
426
427	list_for_each_entry(p, &br->port_list, list) {
428		features = netdev_increment_features(features,
429						     p->dev->features, mask);
430	}
431	features = netdev_add_tso_features(features, mask);
432
433	return features;
434}
435
436/* called with RTNL */
437int br_add_if(struct net_bridge *br, struct net_device *dev)
438{
439	struct net_bridge_port *p;
440	int err = 0;
441	bool changed_addr;
442
443	/* Don't allow bridging non-ethernet like devices, or DSA-enabled
444	 * master network devices since the bridge layer rx_handler prevents
445	 * the DSA fake ethertype handler to be invoked, so we do not strip off
446	 * the DSA switch tag protocol header and the bridge layer just return
447	 * RX_HANDLER_CONSUMED, stopping RX processing for these frames.
448	 */
449	if ((dev->flags & IFF_LOOPBACK) ||
450	    dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN ||
451	    !is_valid_ether_addr(dev->dev_addr) ||
452	    netdev_uses_dsa(dev))
453		return -EINVAL;
454
455	/* No bridging of bridges */
456	if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit)
457		return -ELOOP;
458
459	/* Device is already being bridged */
460	if (br_port_exists(dev))
461		return -EBUSY;
462
463	/* No bridging devices that dislike that (e.g. wireless) */
464	if (dev->priv_flags & IFF_DONT_BRIDGE)
465		return -EOPNOTSUPP;
466
467	p = new_nbp(br, dev);
468	if (IS_ERR(p))
469		return PTR_ERR(p);
470
471	call_netdevice_notifiers(NETDEV_JOIN, dev);
472
473	err = dev_set_allmulti(dev, 1);
474	if (err)
475		goto put_back;
476
477	err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
478				   SYSFS_BRIDGE_PORT_ATTR);
479	if (err)
480		goto err1;
481
482	err = br_sysfs_addif(p);
483	if (err)
484		goto err2;
485
486	err = br_netpoll_enable(p);
487	if (err)
488		goto err3;
489
490	err = netdev_rx_handler_register(dev, br_handle_frame, p);
491	if (err)
492		goto err4;
493
494	dev->priv_flags |= IFF_BRIDGE_PORT;
495
496	err = netdev_master_upper_dev_link(dev, br->dev);
497	if (err)
498		goto err5;
499
500	dev_disable_lro(dev);
501
502	list_add_rcu(&p->list, &br->port_list);
503
504	nbp_update_port_count(br);
505
506	netdev_update_features(br->dev);
507
508	if (br->dev->needed_headroom < dev->needed_headroom)
509		br->dev->needed_headroom = dev->needed_headroom;
510
511	if (br_fdb_insert(br, p, dev->dev_addr, 0))
512		netdev_err(dev, "failed insert local address bridge forwarding table\n");
513
514	if (nbp_vlan_init(p))
515		netdev_err(dev, "failed to initialize vlan filtering on this port\n");
516
517	spin_lock_bh(&br->lock);
518	changed_addr = br_stp_recalculate_bridge_id(br);
519
520	if (netif_running(dev) && netif_oper_up(dev) &&
521	    (br->dev->flags & IFF_UP))
522		br_stp_enable_port(p);
523	spin_unlock_bh(&br->lock);
524
525	br_ifinfo_notify(RTM_NEWLINK, p);
526
527	if (changed_addr)
528		call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
529
530	dev_set_mtu(br->dev, br_min_mtu(br));
531
532	kobject_uevent(&p->kobj, KOBJ_ADD);
533
534	return 0;
535
536err5:
537	dev->priv_flags &= ~IFF_BRIDGE_PORT;
538	netdev_rx_handler_unregister(dev);
539err4:
540	br_netpoll_disable(p);
541err3:
542	sysfs_remove_link(br->ifobj, p->dev->name);
543err2:
544	kobject_put(&p->kobj);
545	p = NULL; /* kobject_put frees */
546err1:
547	dev_set_allmulti(dev, -1);
548put_back:
549	dev_put(dev);
550	kfree(p);
551	return err;
552}
553
554/* called with RTNL */
555int br_del_if(struct net_bridge *br, struct net_device *dev)
556{
557	struct net_bridge_port *p;
558	bool changed_addr;
559
560	p = br_port_get_rtnl(dev);
561	if (!p || p->br != br)
562		return -EINVAL;
563
564	/* Since more than one interface can be attached to a bridge,
565	 * there still maybe an alternate path for netconsole to use;
566	 * therefore there is no reason for a NETDEV_RELEASE event.
567	 */
568	del_nbp(p);
569
570	dev_set_mtu(br->dev, br_min_mtu(br));
571
572	spin_lock_bh(&br->lock);
573	changed_addr = br_stp_recalculate_bridge_id(br);
574	spin_unlock_bh(&br->lock);
575
576	if (changed_addr)
577		call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
578
579	netdev_update_features(br->dev);
580
581	return 0;
582}
583
584void br_port_flags_change(struct net_bridge_port *p, unsigned long mask)
585{
586	struct net_bridge *br = p->br;
587
588	if (mask & BR_AUTO_MASK)
589		nbp_update_port_count(br);
590}
591