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/kmod.h> 16 #include <linux/etherdevice.h> 17 #include <linux/rtnetlink.h> 18 #include <net/switchdev.h> 19 20 #include "br_private.h" 21 #include "br_private_stp.h" 22 23 24 /* Port id is composed of priority and port number. 25 * NB: some bits of priority are dropped to 26 * make room for more ports. 27 */ 28 static inline port_id br_make_port_id(__u8 priority, __u16 port_no) 29 { 30 return ((u16)priority << BR_PORT_BITS) 31 | (port_no & ((1<<BR_PORT_BITS)-1)); 32 } 33 34 #define BR_MAX_PORT_PRIORITY ((u16)~0 >> BR_PORT_BITS) 35 36 /* called under bridge lock */ 37 void br_init_port(struct net_bridge_port *p) 38 { 39 struct switchdev_attr attr = { 40 .orig_dev = p->dev, 41 .id = SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME, 42 .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP | SWITCHDEV_F_DEFER, 43 .u.ageing_time = jiffies_to_clock_t(p->br->ageing_time), 44 }; 45 int err; 46 47 p->port_id = br_make_port_id(p->priority, p->port_no); 48 br_become_designated_port(p); 49 br_set_state(p, BR_STATE_BLOCKING); 50 p->topology_change_ack = 0; 51 p->config_pending = 0; 52 53 err = switchdev_port_attr_set(p->dev, &attr); 54 if (err && err != -EOPNOTSUPP) 55 netdev_err(p->dev, "failed to set HW ageing time\n"); 56 } 57 58 /* NO locks held */ 59 void br_stp_enable_bridge(struct net_bridge *br) 60 { 61 struct net_bridge_port *p; 62 63 spin_lock_bh(&br->lock); 64 if (br->stp_enabled == BR_KERNEL_STP) 65 mod_timer(&br->hello_timer, jiffies + br->hello_time); 66 mod_timer(&br->gc_timer, jiffies + HZ/10); 67 68 br_config_bpdu_generation(br); 69 70 list_for_each_entry(p, &br->port_list, list) { 71 if (netif_running(p->dev) && netif_oper_up(p->dev)) 72 br_stp_enable_port(p); 73 74 } 75 spin_unlock_bh(&br->lock); 76 } 77 78 /* NO locks held */ 79 void br_stp_disable_bridge(struct net_bridge *br) 80 { 81 struct net_bridge_port *p; 82 83 spin_lock_bh(&br->lock); 84 list_for_each_entry(p, &br->port_list, list) { 85 if (p->state != BR_STATE_DISABLED) 86 br_stp_disable_port(p); 87 88 } 89 90 br->topology_change = 0; 91 br->topology_change_detected = 0; 92 spin_unlock_bh(&br->lock); 93 94 del_timer_sync(&br->hello_timer); 95 del_timer_sync(&br->topology_change_timer); 96 del_timer_sync(&br->tcn_timer); 97 del_timer_sync(&br->gc_timer); 98 } 99 100 /* called under bridge lock */ 101 void br_stp_enable_port(struct net_bridge_port *p) 102 { 103 br_init_port(p); 104 br_port_state_selection(p->br); 105 br_ifinfo_notify(RTM_NEWLINK, p); 106 } 107 108 /* called under bridge lock */ 109 void br_stp_disable_port(struct net_bridge_port *p) 110 { 111 struct net_bridge *br = p->br; 112 int wasroot; 113 114 wasroot = br_is_root_bridge(br); 115 br_become_designated_port(p); 116 br_set_state(p, BR_STATE_DISABLED); 117 p->topology_change_ack = 0; 118 p->config_pending = 0; 119 120 br_ifinfo_notify(RTM_NEWLINK, p); 121 122 del_timer(&p->message_age_timer); 123 del_timer(&p->forward_delay_timer); 124 del_timer(&p->hold_timer); 125 126 br_fdb_delete_by_port(br, p, 0, 0); 127 br_multicast_disable_port(p); 128 129 br_configuration_update(br); 130 131 br_port_state_selection(br); 132 133 if (br_is_root_bridge(br) && !wasroot) 134 br_become_root_bridge(br); 135 } 136 137 static int br_stp_call_user(struct net_bridge *br, char *arg) 138 { 139 char *argv[] = { BR_STP_PROG, br->dev->name, arg, NULL }; 140 char *envp[] = { NULL }; 141 int rc; 142 143 /* call userspace STP and report program errors */ 144 rc = call_usermodehelper(BR_STP_PROG, argv, envp, UMH_WAIT_PROC); 145 if (rc > 0) { 146 if (rc & 0xff) 147 br_debug(br, BR_STP_PROG " received signal %d\n", 148 rc & 0x7f); 149 else 150 br_debug(br, BR_STP_PROG " exited with code %d\n", 151 (rc >> 8) & 0xff); 152 } 153 154 return rc; 155 } 156 157 static void br_stp_start(struct net_bridge *br) 158 { 159 struct net_bridge_port *p; 160 int err = -ENOENT; 161 162 if (net_eq(dev_net(br->dev), &init_net)) 163 err = br_stp_call_user(br, "start"); 164 165 if (err && err != -ENOENT) 166 br_err(br, "failed to start userspace STP (%d)\n", err); 167 168 spin_lock_bh(&br->lock); 169 170 if (br->bridge_forward_delay < BR_MIN_FORWARD_DELAY) 171 __br_set_forward_delay(br, BR_MIN_FORWARD_DELAY); 172 else if (br->bridge_forward_delay > BR_MAX_FORWARD_DELAY) 173 __br_set_forward_delay(br, BR_MAX_FORWARD_DELAY); 174 175 if (!err) { 176 br->stp_enabled = BR_USER_STP; 177 br_debug(br, "userspace STP started\n"); 178 179 /* Stop hello and hold timers */ 180 del_timer(&br->hello_timer); 181 list_for_each_entry(p, &br->port_list, list) 182 del_timer(&p->hold_timer); 183 } else { 184 br->stp_enabled = BR_KERNEL_STP; 185 br_debug(br, "using kernel STP\n"); 186 187 /* To start timers on any ports left in blocking */ 188 br_port_state_selection(br); 189 } 190 191 spin_unlock_bh(&br->lock); 192 } 193 194 static void br_stp_stop(struct net_bridge *br) 195 { 196 struct net_bridge_port *p; 197 int err; 198 199 if (br->stp_enabled == BR_USER_STP) { 200 err = br_stp_call_user(br, "stop"); 201 if (err) 202 br_err(br, "failed to stop userspace STP (%d)\n", err); 203 204 /* To start timers on any ports left in blocking */ 205 mod_timer(&br->hello_timer, jiffies + br->hello_time); 206 list_for_each_entry(p, &br->port_list, list) 207 mod_timer(&p->hold_timer, 208 round_jiffies(jiffies + BR_HOLD_TIME)); 209 spin_lock_bh(&br->lock); 210 br_port_state_selection(br); 211 spin_unlock_bh(&br->lock); 212 } 213 214 br->stp_enabled = BR_NO_STP; 215 } 216 217 void br_stp_set_enabled(struct net_bridge *br, unsigned long val) 218 { 219 ASSERT_RTNL(); 220 221 if (val) { 222 if (br->stp_enabled == BR_NO_STP) 223 br_stp_start(br); 224 } else { 225 if (br->stp_enabled != BR_NO_STP) 226 br_stp_stop(br); 227 } 228 } 229 230 /* called under bridge lock */ 231 void br_stp_change_bridge_id(struct net_bridge *br, const unsigned char *addr) 232 { 233 /* should be aligned on 2 bytes for ether_addr_equal() */ 234 unsigned short oldaddr_aligned[ETH_ALEN >> 1]; 235 unsigned char *oldaddr = (unsigned char *)oldaddr_aligned; 236 struct net_bridge_port *p; 237 int wasroot; 238 239 wasroot = br_is_root_bridge(br); 240 241 br_fdb_change_mac_address(br, addr); 242 243 memcpy(oldaddr, br->bridge_id.addr, ETH_ALEN); 244 memcpy(br->bridge_id.addr, addr, ETH_ALEN); 245 memcpy(br->dev->dev_addr, addr, ETH_ALEN); 246 247 list_for_each_entry(p, &br->port_list, list) { 248 if (ether_addr_equal(p->designated_bridge.addr, oldaddr)) 249 memcpy(p->designated_bridge.addr, addr, ETH_ALEN); 250 251 if (ether_addr_equal(p->designated_root.addr, oldaddr)) 252 memcpy(p->designated_root.addr, addr, ETH_ALEN); 253 } 254 255 br_configuration_update(br); 256 br_port_state_selection(br); 257 if (br_is_root_bridge(br) && !wasroot) 258 br_become_root_bridge(br); 259 } 260 261 /* should be aligned on 2 bytes for ether_addr_equal() */ 262 static const unsigned short br_mac_zero_aligned[ETH_ALEN >> 1]; 263 264 /* called under bridge lock */ 265 bool br_stp_recalculate_bridge_id(struct net_bridge *br) 266 { 267 const unsigned char *br_mac_zero = 268 (const unsigned char *)br_mac_zero_aligned; 269 const unsigned char *addr = br_mac_zero; 270 struct net_bridge_port *p; 271 272 /* user has chosen a value so keep it */ 273 if (br->dev->addr_assign_type == NET_ADDR_SET) 274 return false; 275 276 list_for_each_entry(p, &br->port_list, list) { 277 if (addr == br_mac_zero || 278 memcmp(p->dev->dev_addr, addr, ETH_ALEN) < 0) 279 addr = p->dev->dev_addr; 280 281 } 282 283 if (ether_addr_equal(br->bridge_id.addr, addr)) 284 return false; /* no change */ 285 286 br_stp_change_bridge_id(br, addr); 287 return true; 288 } 289 290 /* Acquires and releases bridge lock */ 291 void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio) 292 { 293 struct net_bridge_port *p; 294 int wasroot; 295 296 spin_lock_bh(&br->lock); 297 wasroot = br_is_root_bridge(br); 298 299 list_for_each_entry(p, &br->port_list, list) { 300 if (p->state != BR_STATE_DISABLED && 301 br_is_designated_port(p)) { 302 p->designated_bridge.prio[0] = (newprio >> 8) & 0xFF; 303 p->designated_bridge.prio[1] = newprio & 0xFF; 304 } 305 306 } 307 308 br->bridge_id.prio[0] = (newprio >> 8) & 0xFF; 309 br->bridge_id.prio[1] = newprio & 0xFF; 310 br_configuration_update(br); 311 br_port_state_selection(br); 312 if (br_is_root_bridge(br) && !wasroot) 313 br_become_root_bridge(br); 314 spin_unlock_bh(&br->lock); 315 } 316 317 /* called under bridge lock */ 318 int br_stp_set_port_priority(struct net_bridge_port *p, unsigned long newprio) 319 { 320 port_id new_port_id; 321 322 if (newprio > BR_MAX_PORT_PRIORITY) 323 return -ERANGE; 324 325 new_port_id = br_make_port_id(newprio, p->port_no); 326 if (br_is_designated_port(p)) 327 p->designated_port = new_port_id; 328 329 p->port_id = new_port_id; 330 p->priority = newprio; 331 if (!memcmp(&p->br->bridge_id, &p->designated_bridge, 8) && 332 p->port_id < p->designated_port) { 333 br_become_designated_port(p); 334 br_port_state_selection(p->br); 335 } 336 337 return 0; 338 } 339 340 /* called under bridge lock */ 341 int br_stp_set_path_cost(struct net_bridge_port *p, unsigned long path_cost) 342 { 343 if (path_cost < BR_MIN_PATH_COST || 344 path_cost > BR_MAX_PATH_COST) 345 return -ERANGE; 346 347 p->flags |= BR_ADMIN_COST; 348 p->path_cost = path_cost; 349 br_configuration_update(p->br); 350 br_port_state_selection(p->br); 351 return 0; 352 } 353 354 ssize_t br_show_bridge_id(char *buf, const struct bridge_id *id) 355 { 356 return sprintf(buf, "%.2x%.2x.%.2x%.2x%.2x%.2x%.2x%.2x\n", 357 id->prio[0], id->prio[1], 358 id->addr[0], id->addr[1], id->addr[2], 359 id->addr[3], id->addr[4], id->addr[5]); 360 } 361