br_mst.c 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Bridge Multiple Spanning Tree Support
  4. *
  5. * Authors:
  6. * Tobias Waldekranz <[email protected]>
  7. */
  8. #include <linux/kernel.h>
  9. #include <net/switchdev.h>
  10. #include "br_private.h"
  11. DEFINE_STATIC_KEY_FALSE(br_mst_used);
  12. bool br_mst_enabled(const struct net_device *dev)
  13. {
  14. if (!netif_is_bridge_master(dev))
  15. return false;
  16. return br_opt_get(netdev_priv(dev), BROPT_MST_ENABLED);
  17. }
  18. EXPORT_SYMBOL_GPL(br_mst_enabled);
  19. int br_mst_get_info(const struct net_device *dev, u16 msti, unsigned long *vids)
  20. {
  21. const struct net_bridge_vlan_group *vg;
  22. const struct net_bridge_vlan *v;
  23. const struct net_bridge *br;
  24. ASSERT_RTNL();
  25. if (!netif_is_bridge_master(dev))
  26. return -EINVAL;
  27. br = netdev_priv(dev);
  28. if (!br_opt_get(br, BROPT_MST_ENABLED))
  29. return -EINVAL;
  30. vg = br_vlan_group(br);
  31. list_for_each_entry(v, &vg->vlan_list, vlist) {
  32. if (v->msti == msti)
  33. __set_bit(v->vid, vids);
  34. }
  35. return 0;
  36. }
  37. EXPORT_SYMBOL_GPL(br_mst_get_info);
  38. int br_mst_get_state(const struct net_device *dev, u16 msti, u8 *state)
  39. {
  40. const struct net_bridge_port *p = NULL;
  41. const struct net_bridge_vlan_group *vg;
  42. const struct net_bridge_vlan *v;
  43. ASSERT_RTNL();
  44. p = br_port_get_check_rtnl(dev);
  45. if (!p || !br_opt_get(p->br, BROPT_MST_ENABLED))
  46. return -EINVAL;
  47. vg = nbp_vlan_group(p);
  48. list_for_each_entry(v, &vg->vlan_list, vlist) {
  49. if (v->brvlan->msti == msti) {
  50. *state = v->state;
  51. return 0;
  52. }
  53. }
  54. return -ENOENT;
  55. }
  56. EXPORT_SYMBOL_GPL(br_mst_get_state);
  57. static void br_mst_vlan_set_state(struct net_bridge_port *p, struct net_bridge_vlan *v,
  58. u8 state)
  59. {
  60. struct net_bridge_vlan_group *vg = nbp_vlan_group(p);
  61. if (v->state == state)
  62. return;
  63. br_vlan_set_state(v, state);
  64. if (v->vid == vg->pvid)
  65. br_vlan_set_pvid_state(vg, state);
  66. }
  67. int br_mst_set_state(struct net_bridge_port *p, u16 msti, u8 state,
  68. struct netlink_ext_ack *extack)
  69. {
  70. struct switchdev_attr attr = {
  71. .id = SWITCHDEV_ATTR_ID_PORT_MST_STATE,
  72. .orig_dev = p->dev,
  73. .u.mst_state = {
  74. .msti = msti,
  75. .state = state,
  76. },
  77. };
  78. struct net_bridge_vlan_group *vg;
  79. struct net_bridge_vlan *v;
  80. int err;
  81. vg = nbp_vlan_group(p);
  82. if (!vg)
  83. return 0;
  84. /* MSTI 0 (CST) state changes are notified via the regular
  85. * SWITCHDEV_ATTR_ID_PORT_STP_STATE.
  86. */
  87. if (msti) {
  88. err = switchdev_port_attr_set(p->dev, &attr, extack);
  89. if (err && err != -EOPNOTSUPP)
  90. return err;
  91. }
  92. list_for_each_entry(v, &vg->vlan_list, vlist) {
  93. if (v->brvlan->msti != msti)
  94. continue;
  95. br_mst_vlan_set_state(p, v, state);
  96. }
  97. return 0;
  98. }
  99. static void br_mst_vlan_sync_state(struct net_bridge_vlan *pv, u16 msti)
  100. {
  101. struct net_bridge_vlan_group *vg = nbp_vlan_group(pv->port);
  102. struct net_bridge_vlan *v;
  103. list_for_each_entry(v, &vg->vlan_list, vlist) {
  104. /* If this port already has a defined state in this
  105. * MSTI (through some other VLAN membership), inherit
  106. * it.
  107. */
  108. if (v != pv && v->brvlan->msti == msti) {
  109. br_mst_vlan_set_state(pv->port, pv, v->state);
  110. return;
  111. }
  112. }
  113. /* Otherwise, start out in a new MSTI with all ports disabled. */
  114. return br_mst_vlan_set_state(pv->port, pv, BR_STATE_DISABLED);
  115. }
  116. int br_mst_vlan_set_msti(struct net_bridge_vlan *mv, u16 msti)
  117. {
  118. struct switchdev_attr attr = {
  119. .id = SWITCHDEV_ATTR_ID_VLAN_MSTI,
  120. .orig_dev = mv->br->dev,
  121. .u.vlan_msti = {
  122. .vid = mv->vid,
  123. .msti = msti,
  124. },
  125. };
  126. struct net_bridge_vlan_group *vg;
  127. struct net_bridge_vlan *pv;
  128. struct net_bridge_port *p;
  129. int err;
  130. if (mv->msti == msti)
  131. return 0;
  132. err = switchdev_port_attr_set(mv->br->dev, &attr, NULL);
  133. if (err && err != -EOPNOTSUPP)
  134. return err;
  135. mv->msti = msti;
  136. list_for_each_entry(p, &mv->br->port_list, list) {
  137. vg = nbp_vlan_group(p);
  138. pv = br_vlan_find(vg, mv->vid);
  139. if (pv)
  140. br_mst_vlan_sync_state(pv, msti);
  141. }
  142. return 0;
  143. }
  144. void br_mst_vlan_init_state(struct net_bridge_vlan *v)
  145. {
  146. /* VLANs always start out in MSTI 0 (CST) */
  147. v->msti = 0;
  148. if (br_vlan_is_master(v))
  149. v->state = BR_STATE_FORWARDING;
  150. else
  151. v->state = v->port->state;
  152. }
  153. int br_mst_set_enabled(struct net_bridge *br, bool on,
  154. struct netlink_ext_ack *extack)
  155. {
  156. struct switchdev_attr attr = {
  157. .id = SWITCHDEV_ATTR_ID_BRIDGE_MST,
  158. .orig_dev = br->dev,
  159. .u.mst = on,
  160. };
  161. struct net_bridge_vlan_group *vg;
  162. struct net_bridge_port *p;
  163. int err;
  164. list_for_each_entry(p, &br->port_list, list) {
  165. vg = nbp_vlan_group(p);
  166. if (!vg->num_vlans)
  167. continue;
  168. NL_SET_ERR_MSG(extack,
  169. "MST mode can't be changed while VLANs exist");
  170. return -EBUSY;
  171. }
  172. if (br_opt_get(br, BROPT_MST_ENABLED) == on)
  173. return 0;
  174. err = switchdev_port_attr_set(br->dev, &attr, extack);
  175. if (err && err != -EOPNOTSUPP)
  176. return err;
  177. if (on)
  178. static_branch_enable(&br_mst_used);
  179. else
  180. static_branch_disable(&br_mst_used);
  181. br_opt_toggle(br, BROPT_MST_ENABLED, on);
  182. return 0;
  183. }
  184. size_t br_mst_info_size(const struct net_bridge_vlan_group *vg)
  185. {
  186. DECLARE_BITMAP(seen, VLAN_N_VID) = { 0 };
  187. const struct net_bridge_vlan *v;
  188. size_t sz;
  189. /* IFLA_BRIDGE_MST */
  190. sz = nla_total_size(0);
  191. list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
  192. if (test_bit(v->brvlan->msti, seen))
  193. continue;
  194. /* IFLA_BRIDGE_MST_ENTRY */
  195. sz += nla_total_size(0) +
  196. /* IFLA_BRIDGE_MST_ENTRY_MSTI */
  197. nla_total_size(sizeof(u16)) +
  198. /* IFLA_BRIDGE_MST_ENTRY_STATE */
  199. nla_total_size(sizeof(u8));
  200. __set_bit(v->brvlan->msti, seen);
  201. }
  202. return sz;
  203. }
  204. int br_mst_fill_info(struct sk_buff *skb,
  205. const struct net_bridge_vlan_group *vg)
  206. {
  207. DECLARE_BITMAP(seen, VLAN_N_VID) = { 0 };
  208. const struct net_bridge_vlan *v;
  209. struct nlattr *nest;
  210. int err = 0;
  211. list_for_each_entry(v, &vg->vlan_list, vlist) {
  212. if (test_bit(v->brvlan->msti, seen))
  213. continue;
  214. nest = nla_nest_start_noflag(skb, IFLA_BRIDGE_MST_ENTRY);
  215. if (!nest ||
  216. nla_put_u16(skb, IFLA_BRIDGE_MST_ENTRY_MSTI, v->brvlan->msti) ||
  217. nla_put_u8(skb, IFLA_BRIDGE_MST_ENTRY_STATE, v->state)) {
  218. err = -EMSGSIZE;
  219. break;
  220. }
  221. nla_nest_end(skb, nest);
  222. __set_bit(v->brvlan->msti, seen);
  223. }
  224. return err;
  225. }
  226. static const struct nla_policy br_mst_nl_policy[IFLA_BRIDGE_MST_ENTRY_MAX + 1] = {
  227. [IFLA_BRIDGE_MST_ENTRY_MSTI] = NLA_POLICY_RANGE(NLA_U16,
  228. 1, /* 0 reserved for CST */
  229. VLAN_N_VID - 1),
  230. [IFLA_BRIDGE_MST_ENTRY_STATE] = NLA_POLICY_RANGE(NLA_U8,
  231. BR_STATE_DISABLED,
  232. BR_STATE_BLOCKING),
  233. };
  234. static int br_mst_process_one(struct net_bridge_port *p,
  235. const struct nlattr *attr,
  236. struct netlink_ext_ack *extack)
  237. {
  238. struct nlattr *tb[IFLA_BRIDGE_MST_ENTRY_MAX + 1];
  239. u16 msti;
  240. u8 state;
  241. int err;
  242. err = nla_parse_nested(tb, IFLA_BRIDGE_MST_ENTRY_MAX, attr,
  243. br_mst_nl_policy, extack);
  244. if (err)
  245. return err;
  246. if (!tb[IFLA_BRIDGE_MST_ENTRY_MSTI]) {
  247. NL_SET_ERR_MSG_MOD(extack, "MSTI not specified");
  248. return -EINVAL;
  249. }
  250. if (!tb[IFLA_BRIDGE_MST_ENTRY_STATE]) {
  251. NL_SET_ERR_MSG_MOD(extack, "State not specified");
  252. return -EINVAL;
  253. }
  254. msti = nla_get_u16(tb[IFLA_BRIDGE_MST_ENTRY_MSTI]);
  255. state = nla_get_u8(tb[IFLA_BRIDGE_MST_ENTRY_STATE]);
  256. return br_mst_set_state(p, msti, state, extack);
  257. }
  258. int br_mst_process(struct net_bridge_port *p, const struct nlattr *mst_attr,
  259. struct netlink_ext_ack *extack)
  260. {
  261. struct nlattr *attr;
  262. int err, msts = 0;
  263. int rem;
  264. if (!br_opt_get(p->br, BROPT_MST_ENABLED)) {
  265. NL_SET_ERR_MSG_MOD(extack, "Can't modify MST state when MST is disabled");
  266. return -EBUSY;
  267. }
  268. nla_for_each_nested(attr, mst_attr, rem) {
  269. switch (nla_type(attr)) {
  270. case IFLA_BRIDGE_MST_ENTRY:
  271. err = br_mst_process_one(p, attr, extack);
  272. break;
  273. default:
  274. continue;
  275. }
  276. msts++;
  277. if (err)
  278. break;
  279. }
  280. if (!msts) {
  281. NL_SET_ERR_MSG_MOD(extack, "Found no MST entries to process");
  282. err = -EINVAL;
  283. }
  284. return err;
  285. }