/net/bridge/br_stp_if.c

  1/*
  2 *	Spanning tree protocol; interface code
  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/etherdevice.h>
 16#include <linux/rtnetlink.h>
 17
 18#include "br_private.h"
 19#include "br_private_stp.h"
 20
 21
 22/* Port id is composed of priority and port number.
 23 * NB: least significant bits of priority are dropped to
 24 *     make room for more ports.
 25 */
 26static inline port_id br_make_port_id(__u8 priority, __u16 port_no)
 27{
 28	return ((u16)priority << BR_PORT_BITS)
 29		| (port_no & ((1<<BR_PORT_BITS)-1));
 30}
 31
 32/* called under bridge lock */
 33void br_init_port(struct net_bridge_port *p)
 34{
 35	p->port_id = br_make_port_id(p->priority, p->port_no);
 36	br_become_designated_port(p);
 37	p->state = BR_STATE_BLOCKING;
 38	p->topology_change_ack = 0;
 39	p->config_pending = 0;
 40}
 41
 42/* called under bridge lock */
 43void br_stp_enable_bridge(struct net_bridge *br)
 44{
 45	struct net_bridge_port *p;
 46
 47	spin_lock_bh(&br->lock);
 48	mod_timer(&br->hello_timer, jiffies + br->hello_time);
 49	mod_timer(&br->gc_timer, jiffies + HZ/10);
 50
 51	br_config_bpdu_generation(br);
 52
 53	list_for_each_entry(p, &br->port_list, list) {
 54		if ((p->dev->flags & IFF_UP) && netif_carrier_ok(p->dev))
 55			br_stp_enable_port(p);
 56
 57	}
 58	spin_unlock_bh(&br->lock);
 59}
 60
 61/* NO locks held */
 62void br_stp_disable_bridge(struct net_bridge *br)
 63{
 64	struct net_bridge_port *p;
 65
 66	spin_lock_bh(&br->lock);
 67	list_for_each_entry(p, &br->port_list, list) {
 68		if (p->state != BR_STATE_DISABLED)
 69			br_stp_disable_port(p);
 70
 71	}
 72
 73	br->topology_change = 0;
 74	br->topology_change_detected = 0;
 75	spin_unlock_bh(&br->lock);
 76
 77	del_timer_sync(&br->hello_timer);
 78	del_timer_sync(&br->topology_change_timer);
 79	del_timer_sync(&br->tcn_timer);
 80	del_timer_sync(&br->gc_timer);
 81}
 82
 83/* called under bridge lock */
 84void br_stp_enable_port(struct net_bridge_port *p)
 85{
 86	br_init_port(p);
 87	br_port_state_selection(p->br);
 88}
 89
 90/* called under bridge lock */
 91void br_stp_disable_port(struct net_bridge_port *p)
 92{
 93	struct net_bridge *br;
 94	int wasroot;
 95
 96	br = p->br;
 97	printk(KERN_INFO "%s: port %i(%s) entering %s state\n",
 98	       br->dev->name, p->port_no, p->dev->name, "disabled");
 99
100	wasroot = br_is_root_bridge(br);
101	br_become_designated_port(p);
102	p->state = BR_STATE_DISABLED;
103	p->topology_change_ack = 0;
104	p->config_pending = 0;
105
106	del_timer(&p->message_age_timer);
107	del_timer(&p->forward_delay_timer);
108	del_timer(&p->hold_timer);
109
110	br_fdb_delete_by_port(br, p, 0);
111	br_multicast_disable_port(p);
112
113	br_configuration_update(br);
114
115	br_port_state_selection(br);
116
117	if (br_is_root_bridge(br) && !wasroot)
118		br_become_root_bridge(br);
119}
120
121static void br_stp_start(struct net_bridge *br)
122{
123	int r;
124	char *argv[] = { BR_STP_PROG, br->dev->name, "start", NULL };
125	char *envp[] = { NULL };
126
127	r = call_usermodehelper(BR_STP_PROG, argv, envp, UMH_WAIT_PROC);
128	if (r == 0) {
129		br->stp_enabled = BR_USER_STP;
130		printk(KERN_INFO "%s: userspace STP started\n", br->dev->name);
131	} else {
132		br->stp_enabled = BR_KERNEL_STP;
133		printk(KERN_INFO "%s: starting userspace STP failed, "
134				"starting kernel STP\n", br->dev->name);
135
136		/* To start timers on any ports left in blocking */
137		spin_lock_bh(&br->lock);
138		br_port_state_selection(br);
139		spin_unlock_bh(&br->lock);
140	}
141}
142
143static void br_stp_stop(struct net_bridge *br)
144{
145	int r;
146	char *argv[] = { BR_STP_PROG, br->dev->name, "stop", NULL };
147	char *envp[] = { NULL };
148
149	if (br->stp_enabled == BR_USER_STP) {
150		r = call_usermodehelper(BR_STP_PROG, argv, envp, 1);
151		printk(KERN_INFO "%s: userspace STP stopped, return code %d\n",
152			br->dev->name, r);
153
154
155		/* To start timers on any ports left in blocking */
156		spin_lock_bh(&br->lock);
157		br_port_state_selection(br);
158		spin_unlock_bh(&br->lock);
159	}
160
161	br->stp_enabled = BR_NO_STP;
162}
163
164void br_stp_set_enabled(struct net_bridge *br, unsigned long val)
165{
166	ASSERT_RTNL();
167
168	if (val) {
169		if (br->stp_enabled == BR_NO_STP)
170			br_stp_start(br);
171	} else {
172		if (br->stp_enabled != BR_NO_STP)
173			br_stp_stop(br);
174	}
175}
176
177/* called under bridge lock */
178void br_stp_change_bridge_id(struct net_bridge *br, const unsigned char *addr)
179{
180	/* should be aligned on 2 bytes for compare_ether_addr() */
181	unsigned short oldaddr_aligned[ETH_ALEN >> 1];
182	unsigned char *oldaddr = (unsigned char *)oldaddr_aligned;
183	struct net_bridge_port *p;
184	int wasroot;
185
186	wasroot = br_is_root_bridge(br);
187
188	memcpy(oldaddr, br->bridge_id.addr, ETH_ALEN);
189	memcpy(br->bridge_id.addr, addr, ETH_ALEN);
190	memcpy(br->dev->dev_addr, addr, ETH_ALEN);
191
192	list_for_each_entry(p, &br->port_list, list) {
193		if (!compare_ether_addr(p->designated_bridge.addr, oldaddr))
194			memcpy(p->designated_bridge.addr, addr, ETH_ALEN);
195
196		if (!compare_ether_addr(p->designated_root.addr, oldaddr))
197			memcpy(p->designated_root.addr, addr, ETH_ALEN);
198
199	}
200
201	br_configuration_update(br);
202	br_port_state_selection(br);
203	if (br_is_root_bridge(br) && !wasroot)
204		br_become_root_bridge(br);
205}
206
207/* should be aligned on 2 bytes for compare_ether_addr() */
208static const unsigned short br_mac_zero_aligned[ETH_ALEN >> 1];
209
210/* called under bridge lock */
211void br_stp_recalculate_bridge_id(struct net_bridge *br)
212{
213	const unsigned char *br_mac_zero =
214			(const unsigned char *)br_mac_zero_aligned;
215	const unsigned char *addr = br_mac_zero;
216	struct net_bridge_port *p;
217
218	/* user has chosen a value so keep it */
219	if (br->flags & BR_SET_MAC_ADDR)
220		return;
221
222	list_for_each_entry(p, &br->port_list, list) {
223		if (addr == br_mac_zero ||
224		    memcmp(p->dev->dev_addr, addr, ETH_ALEN) < 0)
225			addr = p->dev->dev_addr;
226
227	}
228
229	if (compare_ether_addr(br->bridge_id.addr, addr))
230		br_stp_change_bridge_id(br, addr);
231}
232
233/* called under bridge lock */
234void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio)
235{
236	struct net_bridge_port *p;
237	int wasroot;
238
239	wasroot = br_is_root_bridge(br);
240
241	list_for_each_entry(p, &br->port_list, list) {
242		if (p->state != BR_STATE_DISABLED &&
243		    br_is_designated_port(p)) {
244			p->designated_bridge.prio[0] = (newprio >> 8) & 0xFF;
245			p->designated_bridge.prio[1] = newprio & 0xFF;
246		}
247
248	}
249
250	br->bridge_id.prio[0] = (newprio >> 8) & 0xFF;
251	br->bridge_id.prio[1] = newprio & 0xFF;
252	br_configuration_update(br);
253	br_port_state_selection(br);
254	if (br_is_root_bridge(br) && !wasroot)
255		br_become_root_bridge(br);
256}
257
258/* called under bridge lock */
259void br_stp_set_port_priority(struct net_bridge_port *p, u8 newprio)
260{
261	port_id new_port_id = br_make_port_id(newprio, p->port_no);
262
263	if (br_is_designated_port(p))
264		p->designated_port = new_port_id;
265
266	p->port_id = new_port_id;
267	p->priority = newprio;
268	if (!memcmp(&p->br->bridge_id, &p->designated_bridge, 8) &&
269	    p->port_id < p->designated_port) {
270		br_become_designated_port(p);
271		br_port_state_selection(p->br);
272	}
273}
274
275/* called under bridge lock */
276void br_stp_set_path_cost(struct net_bridge_port *p, u32 path_cost)
277{
278	p->path_cost = path_cost;
279	br_configuration_update(p->br);
280	br_port_state_selection(p->br);
281}
282
283ssize_t br_show_bridge_id(char *buf, const struct bridge_id *id)
284{
285	return sprintf(buf, "%.2x%.2x.%.2x%.2x%.2x%.2x%.2x%.2x\n",
286	       id->prio[0], id->prio[1],
287	       id->addr[0], id->addr[1], id->addr[2],
288	       id->addr[3], id->addr[4], id->addr[5]);
289}