net/bridge/br_stp_if.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Spanning tree protocol; interface code
0004  *  Linux ethernet bridge
0005  *
0006  *  Authors:
0007  *  Lennert Buytenhek       <buytenh@gnu.org>
0008  */
0009
0010 #include <linux/kernel.h>
0011 #include <linux/kmod.h>
0012 #include <linux/etherdevice.h>
0013 #include <linux/rtnetlink.h>
0014 #include <net/switchdev.h>
0015
0016 #include "br_private.h"
0017 #include "br_private_stp.h"
0018
0019
0020 /* Port id is composed of priority and port number.
0021  * NB: some bits of priority are dropped to
0022  *     make room for more ports.
0023  */
0024 static inline port_id br_make_port_id(__u8 priority, __u16 port_no)
0025 {
0026     return ((u16)priority << BR_PORT_BITS)
0027         | (port_no & ((1<<BR_PORT_BITS)-1));
0028 }
0029
0030 #define BR_MAX_PORT_PRIORITY ((u16)~0 >> BR_PORT_BITS)
0031
0032 /* called under bridge lock */
0033 void br_init_port(struct net_bridge_port *p)
0034 {
0035     int err;
0036
0037     p->port_id = br_make_port_id(p->priority, p->port_no);
0038     br_become_designated_port(p);
0039     br_set_state(p, BR_STATE_BLOCKING);
0040     p->topology_change_ack = 0;
0041     p->config_pending = 0;
0042
0043     err = __set_ageing_time(p->dev, p->br->ageing_time);
0044     if (err)
0045         netdev_err(p->dev, "failed to offload ageing time\n");
0046 }
0047
0048 /* NO locks held */
0049 void br_stp_enable_bridge(struct net_bridge *br)
0050 {
0051     struct net_bridge_port *p;
0052
0053     spin_lock_bh(&br->lock);
0054     if (br->stp_enabled == BR_KERNEL_STP)
0055         mod_timer(&br->hello_timer, jiffies + br->hello_time);
0056     mod_delayed_work(system_long_wq, &br->gc_work, HZ / 10);
0057
0058     br_config_bpdu_generation(br);
0059
0060     list_for_each_entry(p, &br->port_list, list) {
0061         if (netif_running(p->dev) && netif_oper_up(p->dev))
0062             br_stp_enable_port(p);
0063
0064     }
0065     spin_unlock_bh(&br->lock);
0066 }
0067
0068 /* NO locks held */
0069 void br_stp_disable_bridge(struct net_bridge *br)
0070 {
0071     struct net_bridge_port *p;
0072
0073     spin_lock_bh(&br->lock);
0074     list_for_each_entry(p, &br->port_list, list) {
0075         if (p->state != BR_STATE_DISABLED)
0076             br_stp_disable_port(p);
0077
0078     }
0079
0080     __br_set_topology_change(br, 0);
0081     br->topology_change_detected = 0;
0082     spin_unlock_bh(&br->lock);
0083
0084     del_timer_sync(&br->hello_timer);
0085     del_timer_sync(&br->topology_change_timer);
0086     del_timer_sync(&br->tcn_timer);
0087     cancel_delayed_work_sync(&br->gc_work);
0088 }
0089
0090 /* called under bridge lock */
0091 void br_stp_enable_port(struct net_bridge_port *p)
0092 {
0093     br_init_port(p);
0094     br_port_state_selection(p->br);
0095     br_ifinfo_notify(RTM_NEWLINK, NULL, p);
0096 }
0097
0098 /* called under bridge lock */
0099 void br_stp_disable_port(struct net_bridge_port *p)
0100 {
0101     struct net_bridge *br = p->br;
0102     int wasroot;
0103
0104     wasroot = br_is_root_bridge(br);
0105     br_become_designated_port(p);
0106     br_set_state(p, BR_STATE_DISABLED);
0107     p->topology_change_ack = 0;
0108     p->config_pending = 0;
0109
0110     br_ifinfo_notify(RTM_NEWLINK, NULL, p);
0111
0112     del_timer(&p->message_age_timer);
0113     del_timer(&p->forward_delay_timer);
0114     del_timer(&p->hold_timer);
0115
0116     if (!rcu_access_pointer(p->backup_port))
0117         br_fdb_delete_by_port(br, p, 0, 0);
0118     br_multicast_disable_port(p);
0119
0120     br_configuration_update(br);
0121
0122     br_port_state_selection(br);
0123
0124     if (br_is_root_bridge(br) && !wasroot)
0125         br_become_root_bridge(br);
0126 }
0127
0128 static int br_stp_call_user(struct net_bridge *br, char *arg)
0129 {
0130     char *argv[] = { BR_STP_PROG, br->dev->name, arg, NULL };
0131     char *envp[] = { NULL };
0132     int rc;
0133
0134     /* call userspace STP and report program errors */
0135     rc = call_usermodehelper(BR_STP_PROG, argv, envp, UMH_WAIT_PROC);
0136     if (rc > 0) {
0137         if (rc & 0xff)
0138             br_debug(br, BR_STP_PROG " received signal %d\n",
0139                  rc & 0x7f);
0140         else
0141             br_debug(br, BR_STP_PROG " exited with code %d\n",
0142                  (rc >> 8) & 0xff);
0143     }
0144
0145     return rc;
0146 }
0147
0148 static void br_stp_start(struct net_bridge *br)
0149 {
0150     int err = -ENOENT;
0151
0152     if (net_eq(dev_net(br->dev), &init_net))
0153         err = br_stp_call_user(br, "start");
0154
0155     if (err && err != -ENOENT)
0156         br_err(br, "failed to start userspace STP (%d)\n", err);
0157
0158     spin_lock_bh(&br->lock);
0159
0160     if (br->bridge_forward_delay < BR_MIN_FORWARD_DELAY)
0161         __br_set_forward_delay(br, BR_MIN_FORWARD_DELAY);
0162     else if (br->bridge_forward_delay > BR_MAX_FORWARD_DELAY)
0163         __br_set_forward_delay(br, BR_MAX_FORWARD_DELAY);
0164
0165     if (!err) {
0166         br->stp_enabled = BR_USER_STP;
0167         br_debug(br, "userspace STP started\n");
0168     } else {
0169         br->stp_enabled = BR_KERNEL_STP;
0170         br_debug(br, "using kernel STP\n");
0171
0172         /* To start timers on any ports left in blocking */
0173         if (br->dev->flags & IFF_UP)
0174             mod_timer(&br->hello_timer, jiffies + br->hello_time);
0175         br_port_state_selection(br);
0176     }
0177
0178     spin_unlock_bh(&br->lock);
0179 }
0180
0181 static void br_stp_stop(struct net_bridge *br)
0182 {
0183     int err;
0184
0185     if (br->stp_enabled == BR_USER_STP) {
0186         err = br_stp_call_user(br, "stop");
0187         if (err)
0188             br_err(br, "failed to stop userspace STP (%d)\n", err);
0189
0190         /* To start timers on any ports left in blocking */
0191         spin_lock_bh(&br->lock);
0192         br_port_state_selection(br);
0193         spin_unlock_bh(&br->lock);
0194     }
0195
0196     br->stp_enabled = BR_NO_STP;
0197 }
0198
0199 int br_stp_set_enabled(struct net_bridge *br, unsigned long val,
0200                struct netlink_ext_ack *extack)
0201 {
0202     ASSERT_RTNL();
0203
0204     if (br_mrp_enabled(br)) {
0205         NL_SET_ERR_MSG_MOD(extack,
0206                    "STP can't be enabled if MRP is already enabled");
0207         return -EINVAL;
0208     }
0209
0210     if (val) {
0211         if (br->stp_enabled == BR_NO_STP)
0212             br_stp_start(br);
0213     } else {
0214         if (br->stp_enabled != BR_NO_STP)
0215             br_stp_stop(br);
0216     }
0217
0218     return 0;
0219 }
0220
0221 /* called under bridge lock */
0222 void br_stp_change_bridge_id(struct net_bridge *br, const unsigned char *addr)
0223 {
0224     /* should be aligned on 2 bytes for ether_addr_equal() */
0225     unsigned short oldaddr_aligned[ETH_ALEN >> 1];
0226     unsigned char *oldaddr = (unsigned char *)oldaddr_aligned;
0227     struct net_bridge_port *p;
0228     int wasroot;
0229
0230     wasroot = br_is_root_bridge(br);
0231
0232     br_fdb_change_mac_address(br, addr);
0233
0234     memcpy(oldaddr, br->bridge_id.addr, ETH_ALEN);
0235     memcpy(br->bridge_id.addr, addr, ETH_ALEN);
0236     eth_hw_addr_set(br->dev, addr);
0237
0238     list_for_each_entry(p, &br->port_list, list) {
0239         if (ether_addr_equal(p->designated_bridge.addr, oldaddr))
0240             memcpy(p->designated_bridge.addr, addr, ETH_ALEN);
0241
0242         if (ether_addr_equal(p->designated_root.addr, oldaddr))
0243             memcpy(p->designated_root.addr, addr, ETH_ALEN);
0244     }
0245
0246     br_configuration_update(br);
0247     br_port_state_selection(br);
0248     if (br_is_root_bridge(br) && !wasroot)
0249         br_become_root_bridge(br);
0250 }
0251
0252 /* should be aligned on 2 bytes for ether_addr_equal() */
0253 static const unsigned short br_mac_zero_aligned[ETH_ALEN >> 1];
0254
0255 /* called under bridge lock */
0256 bool br_stp_recalculate_bridge_id(struct net_bridge *br)
0257 {
0258     const unsigned char *br_mac_zero =
0259             (const unsigned char *)br_mac_zero_aligned;
0260     const unsigned char *addr = br_mac_zero;
0261     struct net_bridge_port *p;
0262
0263     /* user has chosen a value so keep it */
0264     if (br->dev->addr_assign_type == NET_ADDR_SET)
0265         return false;
0266
0267     list_for_each_entry(p, &br->port_list, list) {
0268         if (addr == br_mac_zero ||
0269             memcmp(p->dev->dev_addr, addr, ETH_ALEN) < 0)
0270             addr = p->dev->dev_addr;
0271
0272     }
0273
0274     if (ether_addr_equal(br->bridge_id.addr, addr))
0275         return false;   /* no change */
0276
0277     br_stp_change_bridge_id(br, addr);
0278     return true;
0279 }
0280
0281 /* Acquires and releases bridge lock */
0282 void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio)
0283 {
0284     struct net_bridge_port *p;
0285     int wasroot;
0286
0287     spin_lock_bh(&br->lock);
0288     wasroot = br_is_root_bridge(br);
0289
0290     list_for_each_entry(p, &br->port_list, list) {
0291         if (p->state != BR_STATE_DISABLED &&
0292             br_is_designated_port(p)) {
0293             p->designated_bridge.prio[0] = (newprio >> 8) & 0xFF;
0294             p->designated_bridge.prio[1] = newprio & 0xFF;
0295         }
0296
0297     }
0298
0299     br->bridge_id.prio[0] = (newprio >> 8) & 0xFF;
0300     br->bridge_id.prio[1] = newprio & 0xFF;
0301     br_configuration_update(br);
0302     br_port_state_selection(br);
0303     if (br_is_root_bridge(br) && !wasroot)
0304         br_become_root_bridge(br);
0305     spin_unlock_bh(&br->lock);
0306 }
0307
0308 /* called under bridge lock */
0309 int br_stp_set_port_priority(struct net_bridge_port *p, unsigned long newprio)
0310 {
0311     port_id new_port_id;
0312
0313     if (newprio > BR_MAX_PORT_PRIORITY)
0314         return -ERANGE;
0315
0316     new_port_id = br_make_port_id(newprio, p->port_no);
0317     if (br_is_designated_port(p))
0318         p->designated_port = new_port_id;
0319
0320     p->port_id = new_port_id;
0321     p->priority = newprio;
0322     if (!memcmp(&p->br->bridge_id, &p->designated_bridge, 8) &&
0323         p->port_id < p->designated_port) {
0324         br_become_designated_port(p);
0325         br_port_state_selection(p->br);
0326     }
0327
0328     return 0;
0329 }
0330
0331 /* called under bridge lock */
0332 int br_stp_set_path_cost(struct net_bridge_port *p, unsigned long path_cost)
0333 {
0334     if (path_cost < BR_MIN_PATH_COST ||
0335         path_cost > BR_MAX_PATH_COST)
0336         return -ERANGE;
0337
0338     p->flags |= BR_ADMIN_COST;
0339     p->path_cost = path_cost;
0340     br_configuration_update(p->br);
0341     br_port_state_selection(p->br);
0342     return 0;
0343 }
0344
0345 ssize_t br_show_bridge_id(char *buf, const struct bridge_id *id)
0346 {
0347     return sprintf(buf, "%.2x%.2x.%.2x%.2x%.2x%.2x%.2x%.2x\n",
0348            id->prio[0], id->prio[1],
0349            id->addr[0], id->addr[1], id->addr[2],
0350            id->addr[3], id->addr[4], id->addr[5]);
0351 }