1a4e5c37a0cf2c5efcb4472143d03c3ebeaa73eb
[linux-3.10.git] / 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  */
26 static 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 */
33 void 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 */
43 void 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 */
62 void 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 */
84 void 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 */
91 void 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
112         br_configuration_update(br);
113
114         br_port_state_selection(br);
115
116         if (br_is_root_bridge(br) && !wasroot)
117                 br_become_root_bridge(br);
118 }
119
120 static void br_stp_start(struct net_bridge *br)
121 {
122         int r;
123         char *argv[] = { BR_STP_PROG, br->dev->name, "start", NULL };
124         char *envp[] = { NULL };
125
126         r = call_usermodehelper(BR_STP_PROG, argv, envp, UMH_WAIT_PROC);
127         if (r == 0) {
128                 br->stp_enabled = BR_USER_STP;
129                 printk(KERN_INFO "%s: userspace STP started\n", br->dev->name);
130         } else {
131                 br->stp_enabled = BR_KERNEL_STP;
132                 printk(KERN_INFO "%s: starting userspace STP failed, "
133                                 "starting kernel STP\n", br->dev->name);
134
135                 /* To start timers on any ports left in blocking */
136                 spin_lock_bh(&br->lock);
137                 br_port_state_selection(br);
138                 spin_unlock_bh(&br->lock);
139         }
140 }
141
142 static void br_stp_stop(struct net_bridge *br)
143 {
144         int r;
145         char *argv[] = { BR_STP_PROG, br->dev->name, "stop", NULL };
146         char *envp[] = { NULL };
147
148         if (br->stp_enabled == BR_USER_STP) {
149                 r = call_usermodehelper(BR_STP_PROG, argv, envp, 1);
150                 printk(KERN_INFO "%s: userspace STP stopped, return code %d\n",
151                         br->dev->name, r);
152
153
154                 /* To start timers on any ports left in blocking */
155                 spin_lock_bh(&br->lock);
156                 br_port_state_selection(br);
157                 spin_unlock_bh(&br->lock);
158         }
159
160         br->stp_enabled = BR_NO_STP;
161 }
162
163 void br_stp_set_enabled(struct net_bridge *br, unsigned long val)
164 {
165         ASSERT_RTNL();
166
167         if (val) {
168                 if (br->stp_enabled == BR_NO_STP)
169                         br_stp_start(br);
170         } else {
171                 if (br->stp_enabled != BR_NO_STP)
172                         br_stp_stop(br);
173         }
174 }
175
176 /* called under bridge lock */
177 void br_stp_change_bridge_id(struct net_bridge *br, const unsigned char *addr)
178 {
179         /* should be aligned on 2 bytes for compare_ether_addr() */
180         unsigned short oldaddr_aligned[ETH_ALEN >> 1];
181         unsigned char *oldaddr = (unsigned char *)oldaddr_aligned;
182         struct net_bridge_port *p;
183         int wasroot;
184
185         wasroot = br_is_root_bridge(br);
186
187         memcpy(oldaddr, br->bridge_id.addr, ETH_ALEN);
188         memcpy(br->bridge_id.addr, addr, ETH_ALEN);
189         memcpy(br->dev->dev_addr, addr, ETH_ALEN);
190
191         list_for_each_entry(p, &br->port_list, list) {
192                 if (!compare_ether_addr(p->designated_bridge.addr, oldaddr))
193                         memcpy(p->designated_bridge.addr, addr, ETH_ALEN);
194
195                 if (!compare_ether_addr(p->designated_root.addr, oldaddr))
196                         memcpy(p->designated_root.addr, addr, ETH_ALEN);
197
198         }
199
200         br_configuration_update(br);
201         br_port_state_selection(br);
202         if (br_is_root_bridge(br) && !wasroot)
203                 br_become_root_bridge(br);
204 }
205
206 /* should be aligned on 2 bytes for compare_ether_addr() */
207 static const unsigned short br_mac_zero_aligned[ETH_ALEN >> 1];
208
209 /* called under bridge lock */
210 void br_stp_recalculate_bridge_id(struct net_bridge *br)
211 {
212         const unsigned char *br_mac_zero =
213                         (const unsigned char *)br_mac_zero_aligned;
214         const unsigned char *addr = br_mac_zero;
215         struct net_bridge_port *p;
216
217         list_for_each_entry(p, &br->port_list, list) {
218                 if (addr == br_mac_zero ||
219                     memcmp(p->dev->dev_addr, addr, ETH_ALEN) < 0)
220                         addr = p->dev->dev_addr;
221
222         }
223
224         if (compare_ether_addr(br->bridge_id.addr, addr))
225                 br_stp_change_bridge_id(br, addr);
226 }
227
228 /* called under bridge lock */
229 void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio)
230 {
231         struct net_bridge_port *p;
232         int wasroot;
233
234         wasroot = br_is_root_bridge(br);
235
236         list_for_each_entry(p, &br->port_list, list) {
237                 if (p->state != BR_STATE_DISABLED &&
238                     br_is_designated_port(p)) {
239                         p->designated_bridge.prio[0] = (newprio >> 8) & 0xFF;
240                         p->designated_bridge.prio[1] = newprio & 0xFF;
241                 }
242
243         }
244
245         br->bridge_id.prio[0] = (newprio >> 8) & 0xFF;
246         br->bridge_id.prio[1] = newprio & 0xFF;
247         br_configuration_update(br);
248         br_port_state_selection(br);
249         if (br_is_root_bridge(br) && !wasroot)
250                 br_become_root_bridge(br);
251 }
252
253 /* called under bridge lock */
254 void br_stp_set_port_priority(struct net_bridge_port *p, u8 newprio)
255 {
256         port_id new_port_id = br_make_port_id(newprio, p->port_no);
257
258         if (br_is_designated_port(p))
259                 p->designated_port = new_port_id;
260
261         p->port_id = new_port_id;
262         p->priority = newprio;
263         if (!memcmp(&p->br->bridge_id, &p->designated_bridge, 8) &&
264             p->port_id < p->designated_port) {
265                 br_become_designated_port(p);
266                 br_port_state_selection(p->br);
267         }
268 }
269
270 /* called under bridge lock */
271 void br_stp_set_path_cost(struct net_bridge_port *p, u32 path_cost)
272 {
273         p->path_cost = path_cost;
274         br_configuration_update(p->br);
275         br_port_state_selection(p->br);
276 }
277
278 ssize_t br_show_bridge_id(char *buf, const struct bridge_id *id)
279 {
280         return sprintf(buf, "%.2x%.2x.%.2x%.2x%.2x%.2x%.2x%.2x\n",
281                id->prio[0], id->prio[1],
282                id->addr[0], id->addr[1], id->addr[2],
283                id->addr[3], id->addr[4], id->addr[5]);
284 }