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 br_log_state(p); 89 } 90 91 /* called under bridge lock */ 92 void br_stp_disable_port(struct net_bridge_port *p) 93 { 94 struct net_bridge *br = p->br; 95 int wasroot; 96 97 br_log_state(p); 98 99 wasroot = br_is_root_bridge(br); 100 br_become_designated_port(p); 101 p->state = BR_STATE_DISABLED; 102 p->topology_change_ack = 0; 103 p->config_pending = 0; 104 105 del_timer(&p->message_age_timer); 106 del_timer(&p->forward_delay_timer); 107 del_timer(&p->hold_timer); 108 109 br_fdb_delete_by_port(br, p, 0); 110 br_multicast_disable_port(p); 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 br_debug(br, "userspace STP started\n"); 130 } else { 131 br->stp_enabled = BR_KERNEL_STP; 132 br_debug(br, "using kernel STP\n"); 133 134 /* To start timers on any ports left in blocking */ 135 spin_lock_bh(&br->lock); 136 br_port_state_selection(br); 137 spin_unlock_bh(&br->lock); 138 } 139 } 140 141 static void br_stp_stop(struct net_bridge *br) 142 { 143 int r; 144 char *argv[] = { BR_STP_PROG, br->dev->name, "stop", NULL }; 145 char *envp[] = { NULL }; 146 147 if (br->stp_enabled == BR_USER_STP) { 148 r = call_usermodehelper(BR_STP_PROG, argv, envp, UMH_WAIT_PROC); 149 br_info(br, "userspace STP stopped, return code %d\n", r); 150 151 /* To start timers on any ports left in blocking */ 152 spin_lock_bh(&br->lock); 153 br_port_state_selection(br); 154 spin_unlock_bh(&br->lock); 155 } 156 157 br->stp_enabled = BR_NO_STP; 158 } 159 160 void br_stp_set_enabled(struct net_bridge *br, unsigned long val) 161 { 162 ASSERT_RTNL(); 163 164 if (val) { 165 if (br->stp_enabled == BR_NO_STP) 166 br_stp_start(br); 167 } else { 168 if (br->stp_enabled != BR_NO_STP) 169 br_stp_stop(br); 170 } 171 } 172 173 /* called under bridge lock */ 174 void br_stp_change_bridge_id(struct net_bridge *br, const unsigned char *addr) 175 { 176 /* should be aligned on 2 bytes for compare_ether_addr() */ 177 unsigned short oldaddr_aligned[ETH_ALEN >> 1]; 178 unsigned char *oldaddr = (unsigned char *)oldaddr_aligned; 179 struct net_bridge_port *p; 180 int wasroot; 181 182 wasroot = br_is_root_bridge(br); 183 184 memcpy(oldaddr, br->bridge_id.addr, ETH_ALEN); 185 memcpy(br->bridge_id.addr, addr, ETH_ALEN); 186 memcpy(br->dev->dev_addr, addr, ETH_ALEN); 187 188 list_for_each_entry(p, &br->port_list, list) { 189 if (!compare_ether_addr(p->designated_bridge.addr, oldaddr)) 190 memcpy(p->designated_bridge.addr, addr, ETH_ALEN); 191 192 if (!compare_ether_addr(p->designated_root.addr, oldaddr)) 193 memcpy(p->designated_root.addr, addr, ETH_ALEN); 194 195 } 196 197 br_configuration_update(br); 198 br_port_state_selection(br); 199 if (br_is_root_bridge(br) && !wasroot) 200 br_become_root_bridge(br); 201 } 202 203 /* should be aligned on 2 bytes for compare_ether_addr() */ 204 static const unsigned short br_mac_zero_aligned[ETH_ALEN >> 1]; 205 206 /* called under bridge lock */ 207 void br_stp_recalculate_bridge_id(struct net_bridge *br) 208 { 209 const unsigned char *br_mac_zero = 210 (const unsigned char *)br_mac_zero_aligned; 211 const unsigned char *addr = br_mac_zero; 212 struct net_bridge_port *p; 213 214 /* user has chosen a value so keep it */ 215 if (br->flags & BR_SET_MAC_ADDR) 216 return; 217 218 list_for_each_entry(p, &br->port_list, list) { 219 if (addr == br_mac_zero || 220 memcmp(p->dev->dev_addr, addr, ETH_ALEN) < 0) 221 addr = p->dev->dev_addr; 222 223 } 224 225 if (compare_ether_addr(br->bridge_id.addr, addr)) 226 br_stp_change_bridge_id(br, addr); 227 } 228 229 /* called under bridge lock */ 230 void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio) 231 { 232 struct net_bridge_port *p; 233 int wasroot; 234 235 wasroot = br_is_root_bridge(br); 236 237 list_for_each_entry(p, &br->port_list, list) { 238 if (p->state != BR_STATE_DISABLED && 239 br_is_designated_port(p)) { 240 p->designated_bridge.prio[0] = (newprio >> 8) & 0xFF; 241 p->designated_bridge.prio[1] = newprio & 0xFF; 242 } 243 244 } 245 246 br->bridge_id.prio[0] = (newprio >> 8) & 0xFF; 247 br->bridge_id.prio[1] = newprio & 0xFF; 248 br_configuration_update(br); 249 br_port_state_selection(br); 250 if (br_is_root_bridge(br) && !wasroot) 251 br_become_root_bridge(br); 252 } 253 254 /* called under bridge lock */ 255 void br_stp_set_port_priority(struct net_bridge_port *p, u8 newprio) 256 { 257 port_id new_port_id = br_make_port_id(newprio, p->port_no); 258 259 if (br_is_designated_port(p)) 260 p->designated_port = new_port_id; 261 262 p->port_id = new_port_id; 263 p->priority = newprio; 264 if (!memcmp(&p->br->bridge_id, &p->designated_bridge, 8) && 265 p->port_id < p->designated_port) { 266 br_become_designated_port(p); 267 br_port_state_selection(p->br); 268 } 269 } 270 271 /* called under bridge lock */ 272 void br_stp_set_path_cost(struct net_bridge_port *p, u32 path_cost) 273 { 274 p->path_cost = path_cost; 275 br_configuration_update(p->br); 276 br_port_state_selection(p->br); 277 } 278 279 ssize_t br_show_bridge_id(char *buf, const struct bridge_id *id) 280 { 281 return sprintf(buf, "%.2x%.2x.%.2x%.2x%.2x%.2x%.2x%.2x\n", 282 id->prio[0], id->prio[1], 283 id->addr[0], id->addr[1], id->addr[2], 284 id->addr[3], id->addr[4], id->addr[5]); 285 } 286