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 /* user has chosen a value so keep it */ 218 if (br->flags & BR_SET_MAC_ADDR) 219 return; 220 221 list_for_each_entry(p, &br->port_list, list) { 222 if (addr == br_mac_zero || 223 memcmp(p->dev->dev_addr, addr, ETH_ALEN) < 0) 224 addr = p->dev->dev_addr; 225 226 } 227 228 if (compare_ether_addr(br->bridge_id.addr, addr)) 229 br_stp_change_bridge_id(br, addr); 230 } 231 232 /* called under bridge lock */ 233 void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio) 234 { 235 struct net_bridge_port *p; 236 int wasroot; 237 238 wasroot = br_is_root_bridge(br); 239 240 list_for_each_entry(p, &br->port_list, list) { 241 if (p->state != BR_STATE_DISABLED && 242 br_is_designated_port(p)) { 243 p->designated_bridge.prio[0] = (newprio >> 8) & 0xFF; 244 p->designated_bridge.prio[1] = newprio & 0xFF; 245 } 246 247 } 248 249 br->bridge_id.prio[0] = (newprio >> 8) & 0xFF; 250 br->bridge_id.prio[1] = newprio & 0xFF; 251 br_configuration_update(br); 252 br_port_state_selection(br); 253 if (br_is_root_bridge(br) && !wasroot) 254 br_become_root_bridge(br); 255 } 256 257 /* called under bridge lock */ 258 void br_stp_set_port_priority(struct net_bridge_port *p, u8 newprio) 259 { 260 port_id new_port_id = br_make_port_id(newprio, p->port_no); 261 262 if (br_is_designated_port(p)) 263 p->designated_port = new_port_id; 264 265 p->port_id = new_port_id; 266 p->priority = newprio; 267 if (!memcmp(&p->br->bridge_id, &p->designated_bridge, 8) && 268 p->port_id < p->designated_port) { 269 br_become_designated_port(p); 270 br_port_state_selection(p->br); 271 } 272 } 273 274 /* called under bridge lock */ 275 void br_stp_set_path_cost(struct net_bridge_port *p, u32 path_cost) 276 { 277 p->path_cost = path_cost; 278 br_configuration_update(p->br); 279 br_port_state_selection(p->br); 280 } 281 282 ssize_t br_show_bridge_id(char *buf, const struct bridge_id *id) 283 { 284 return sprintf(buf, "%.2x%.2x.%.2x%.2x%.2x%.2x%.2x%.2x\n", 285 id->prio[0], id->prio[1], 286 id->addr[0], id->addr[1], id->addr[2], 287 id->addr[3], id->addr[4], id->addr[5]); 288 } 289