br_stp_if.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Spanning tree protocol; interface code
  4. * Linux ethernet bridge
  5. *
  6. * Authors:
  7. * Lennert Buytenhek <buytenh@gnu.org>
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/kmod.h>
  11. #include <linux/etherdevice.h>
  12. #include <linux/rtnetlink.h>
  13. #include <net/switchdev.h>
  14. #include "br_private.h"
  15. #include "br_private_stp.h"
  16. /* Port id is composed of priority and port number.
  17. * NB: some bits of priority are dropped to
  18. * make room for more ports.
  19. */
  20. static inline port_id br_make_port_id(__u8 priority, __u16 port_no)
  21. {
  22. return ((u16)priority << BR_PORT_BITS)
  23. | (port_no & ((1<<BR_PORT_BITS)-1));
  24. }
  25. #define BR_MAX_PORT_PRIORITY ((u16)~0 >> BR_PORT_BITS)
  26. /* called under bridge lock */
  27. void br_init_port(struct net_bridge_port *p)
  28. {
  29. int err;
  30. p->port_id = br_make_port_id(p->priority, p->port_no);
  31. br_become_designated_port(p);
  32. br_set_state(p, BR_STATE_BLOCKING);
  33. p->topology_change_ack = 0;
  34. p->config_pending = 0;
  35. err = __set_ageing_time(p->dev, p->br->ageing_time);
  36. if (err)
  37. netdev_err(p->dev, "failed to offload ageing time\n");
  38. }
  39. /* NO locks held */
  40. void br_stp_enable_bridge(struct net_bridge *br)
  41. {
  42. struct net_bridge_port *p;
  43. spin_lock_bh(&br->lock);
  44. if (br->stp_enabled == BR_KERNEL_STP)
  45. mod_timer(&br->hello_timer, jiffies + br->hello_time);
  46. mod_delayed_work(system_long_wq, &br->gc_work, HZ / 10);
  47. br_config_bpdu_generation(br);
  48. list_for_each_entry(p, &br->port_list, list) {
  49. if (netif_running(p->dev) && netif_oper_up(p->dev))
  50. br_stp_enable_port(p);
  51. }
  52. spin_unlock_bh(&br->lock);
  53. }
  54. /* NO locks held */
  55. void br_stp_disable_bridge(struct net_bridge *br)
  56. {
  57. struct net_bridge_port *p;
  58. spin_lock_bh(&br->lock);
  59. list_for_each_entry(p, &br->port_list, list) {
  60. if (p->state != BR_STATE_DISABLED)
  61. br_stp_disable_port(p);
  62. }
  63. __br_set_topology_change(br, 0);
  64. br->topology_change_detected = 0;
  65. spin_unlock_bh(&br->lock);
  66. del_timer_sync(&br->hello_timer);
  67. del_timer_sync(&br->topology_change_timer);
  68. del_timer_sync(&br->tcn_timer);
  69. cancel_delayed_work_sync(&br->gc_work);
  70. }
  71. /* called under bridge lock */
  72. void br_stp_enable_port(struct net_bridge_port *p)
  73. {
  74. br_init_port(p);
  75. br_port_state_selection(p->br);
  76. br_ifinfo_notify(RTM_NEWLINK, NULL, p);
  77. }
  78. /* called under bridge lock */
  79. void br_stp_disable_port(struct net_bridge_port *p)
  80. {
  81. struct net_bridge *br = p->br;
  82. int wasroot;
  83. wasroot = br_is_root_bridge(br);
  84. br_become_designated_port(p);
  85. br_set_state(p, BR_STATE_DISABLED);
  86. p->topology_change_ack = 0;
  87. p->config_pending = 0;
  88. br_ifinfo_notify(RTM_NEWLINK, NULL, p);
  89. del_timer(&p->message_age_timer);
  90. del_timer(&p->forward_delay_timer);
  91. del_timer(&p->hold_timer);
  92. if (!rcu_access_pointer(p->backup_port))
  93. br_fdb_delete_by_port(br, p, 0, 0);
  94. br_multicast_disable_port(p);
  95. br_configuration_update(br);
  96. br_port_state_selection(br);
  97. if (br_is_root_bridge(br) && !wasroot)
  98. br_become_root_bridge(br);
  99. }
  100. static int br_stp_call_user(struct net_bridge *br, char *arg)
  101. {
  102. char *argv[] = { BR_STP_PROG, br->dev->name, arg, NULL };
  103. char *envp[] = { NULL };
  104. int rc;
  105. /* call userspace STP and report program errors */
  106. rc = call_usermodehelper(BR_STP_PROG, argv, envp, UMH_WAIT_PROC);
  107. if (rc > 0) {
  108. if (rc & 0xff)
  109. br_debug(br, BR_STP_PROG " received signal %d\n",
  110. rc & 0x7f);
  111. else
  112. br_debug(br, BR_STP_PROG " exited with code %d\n",
  113. (rc >> 8) & 0xff);
  114. }
  115. return rc;
  116. }
  117. static void br_stp_start(struct net_bridge *br)
  118. {
  119. int err = -ENOENT;
  120. if (net_eq(dev_net(br->dev), &init_net))
  121. err = br_stp_call_user(br, "start");
  122. if (err && err != -ENOENT)
  123. br_err(br, "failed to start userspace STP (%d)\n", err);
  124. spin_lock_bh(&br->lock);
  125. if (br->bridge_forward_delay < BR_MIN_FORWARD_DELAY)
  126. __br_set_forward_delay(br, BR_MIN_FORWARD_DELAY);
  127. else if (br->bridge_forward_delay > BR_MAX_FORWARD_DELAY)
  128. __br_set_forward_delay(br, BR_MAX_FORWARD_DELAY);
  129. if (!err) {
  130. br->stp_enabled = BR_USER_STP;
  131. br_debug(br, "userspace STP started\n");
  132. } else {
  133. br->stp_enabled = BR_KERNEL_STP;
  134. br_debug(br, "using kernel STP\n");
  135. /* To start timers on any ports left in blocking */
  136. if (br->dev->flags & IFF_UP)
  137. mod_timer(&br->hello_timer, jiffies + br->hello_time);
  138. br_port_state_selection(br);
  139. }
  140. spin_unlock_bh(&br->lock);
  141. }
  142. static void br_stp_stop(struct net_bridge *br)
  143. {
  144. int err;
  145. if (br->stp_enabled == BR_USER_STP) {
  146. err = br_stp_call_user(br, "stop");
  147. if (err)
  148. br_err(br, "failed to stop userspace STP (%d)\n", err);
  149. /* To start timers on any ports left in blocking */
  150. spin_lock_bh(&br->lock);
  151. br_port_state_selection(br);
  152. spin_unlock_bh(&br->lock);
  153. }
  154. br->stp_enabled = BR_NO_STP;
  155. }
  156. int br_stp_set_enabled(struct net_bridge *br, unsigned long val,
  157. struct netlink_ext_ack *extack)
  158. {
  159. ASSERT_RTNL();
  160. if (br_mrp_enabled(br)) {
  161. NL_SET_ERR_MSG_MOD(extack,
  162. "STP can't be enabled if MRP is already enabled");
  163. return -EINVAL;
  164. }
  165. if (val) {
  166. if (br->stp_enabled == BR_NO_STP)
  167. br_stp_start(br);
  168. } else {
  169. if (br->stp_enabled != BR_NO_STP)
  170. br_stp_stop(br);
  171. }
  172. return 0;
  173. }
  174. /* called under bridge lock */
  175. void br_stp_change_bridge_id(struct net_bridge *br, const unsigned char *addr)
  176. {
  177. /* should be aligned on 2 bytes for ether_addr_equal() */
  178. unsigned short oldaddr_aligned[ETH_ALEN >> 1];
  179. unsigned char *oldaddr = (unsigned char *)oldaddr_aligned;
  180. struct net_bridge_port *p;
  181. int wasroot;
  182. wasroot = br_is_root_bridge(br);
  183. br_fdb_change_mac_address(br, addr);
  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. list_for_each_entry(p, &br->port_list, list) {
  188. if (ether_addr_equal(p->designated_bridge.addr, oldaddr))
  189. memcpy(p->designated_bridge.addr, addr, ETH_ALEN);
  190. if (ether_addr_equal(p->designated_root.addr, oldaddr))
  191. memcpy(p->designated_root.addr, addr, ETH_ALEN);
  192. }
  193. br_configuration_update(br);
  194. br_port_state_selection(br);
  195. if (br_is_root_bridge(br) && !wasroot)
  196. br_become_root_bridge(br);
  197. }
  198. /* should be aligned on 2 bytes for ether_addr_equal() */
  199. static const unsigned short br_mac_zero_aligned[ETH_ALEN >> 1];
  200. /* called under bridge lock */
  201. bool br_stp_recalculate_bridge_id(struct net_bridge *br)
  202. {
  203. const unsigned char *br_mac_zero =
  204. (const unsigned char *)br_mac_zero_aligned;
  205. const unsigned char *addr = br_mac_zero;
  206. struct net_bridge_port *p;
  207. /* user has chosen a value so keep it */
  208. if (br->dev->addr_assign_type == NET_ADDR_SET)
  209. return false;
  210. list_for_each_entry(p, &br->port_list, list) {
  211. if (addr == br_mac_zero ||
  212. memcmp(p->dev->dev_addr, addr, ETH_ALEN) < 0)
  213. addr = p->dev->dev_addr;
  214. }
  215. if (ether_addr_equal(br->bridge_id.addr, addr))
  216. return false; /* no change */
  217. br_stp_change_bridge_id(br, addr);
  218. return true;
  219. }
  220. /* Acquires and releases bridge lock */
  221. void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio)
  222. {
  223. struct net_bridge_port *p;
  224. int wasroot;
  225. spin_lock_bh(&br->lock);
  226. wasroot = br_is_root_bridge(br);
  227. list_for_each_entry(p, &br->port_list, list) {
  228. if (p->state != BR_STATE_DISABLED &&
  229. br_is_designated_port(p)) {
  230. p->designated_bridge.prio[0] = (newprio >> 8) & 0xFF;
  231. p->designated_bridge.prio[1] = newprio & 0xFF;
  232. }
  233. }
  234. br->bridge_id.prio[0] = (newprio >> 8) & 0xFF;
  235. br->bridge_id.prio[1] = newprio & 0xFF;
  236. br_configuration_update(br);
  237. br_port_state_selection(br);
  238. if (br_is_root_bridge(br) && !wasroot)
  239. br_become_root_bridge(br);
  240. spin_unlock_bh(&br->lock);
  241. }
  242. /* called under bridge lock */
  243. int br_stp_set_port_priority(struct net_bridge_port *p, unsigned long newprio)
  244. {
  245. port_id new_port_id;
  246. if (newprio > BR_MAX_PORT_PRIORITY)
  247. return -ERANGE;
  248. new_port_id = br_make_port_id(newprio, p->port_no);
  249. if (br_is_designated_port(p))
  250. p->designated_port = new_port_id;
  251. p->port_id = new_port_id;
  252. p->priority = newprio;
  253. if (!memcmp(&p->br->bridge_id, &p->designated_bridge, 8) &&
  254. p->port_id < p->designated_port) {
  255. br_become_designated_port(p);
  256. br_port_state_selection(p->br);
  257. }
  258. return 0;
  259. }
  260. /* called under bridge lock */
  261. int br_stp_set_path_cost(struct net_bridge_port *p, unsigned long path_cost)
  262. {
  263. if (path_cost < BR_MIN_PATH_COST ||
  264. path_cost > BR_MAX_PATH_COST)
  265. return -ERANGE;
  266. p->flags |= BR_ADMIN_COST;
  267. p->path_cost = path_cost;
  268. br_configuration_update(p->br);
  269. br_port_state_selection(p->br);
  270. return 0;
  271. }
  272. ssize_t br_show_bridge_id(char *buf, const struct bridge_id *id)
  273. {
  274. return sprintf(buf, "%.2x%.2x.%.2x%.2x%.2x%.2x%.2x%.2x\n",
  275. id->prio[0], id->prio[1],
  276. id->addr[0], id->addr[1], id->addr[2],
  277. id->addr[3], id->addr[4], id->addr[5]);
  278. }