br_stp.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Spanning tree protocol; generic parts
  4. * Linux ethernet bridge
  5. *
  6. * Authors:
  7. * Lennert Buytenhek <[email protected]>
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/rculist.h>
  11. #include <net/switchdev.h>
  12. #include "br_private.h"
  13. #include "br_private_stp.h"
  14. /* since time values in bpdu are in jiffies and then scaled (1/256)
  15. * before sending, make sure that is at least one STP tick.
  16. */
  17. #define MESSAGE_AGE_INCR ((HZ / 256) + 1)
  18. static const char *const br_port_state_names[] = {
  19. [BR_STATE_DISABLED] = "disabled",
  20. [BR_STATE_LISTENING] = "listening",
  21. [BR_STATE_LEARNING] = "learning",
  22. [BR_STATE_FORWARDING] = "forwarding",
  23. [BR_STATE_BLOCKING] = "blocking",
  24. };
  25. void br_set_state(struct net_bridge_port *p, unsigned int state)
  26. {
  27. struct switchdev_attr attr = {
  28. .orig_dev = p->dev,
  29. .id = SWITCHDEV_ATTR_ID_PORT_STP_STATE,
  30. .flags = SWITCHDEV_F_DEFER,
  31. .u.stp_state = state,
  32. };
  33. int err;
  34. /* Don't change the state of the ports if they are driven by a different
  35. * protocol.
  36. */
  37. if (p->flags & BR_MRP_AWARE)
  38. return;
  39. p->state = state;
  40. if (br_opt_get(p->br, BROPT_MST_ENABLED)) {
  41. err = br_mst_set_state(p, 0, state, NULL);
  42. if (err)
  43. br_warn(p->br, "error setting MST state on port %u(%s)\n",
  44. p->port_no, netdev_name(p->dev));
  45. }
  46. err = switchdev_port_attr_set(p->dev, &attr, NULL);
  47. if (err && err != -EOPNOTSUPP)
  48. br_warn(p->br, "error setting offload STP state on port %u(%s)\n",
  49. (unsigned int) p->port_no, p->dev->name);
  50. else
  51. br_info(p->br, "port %u(%s) entered %s state\n",
  52. (unsigned int) p->port_no, p->dev->name,
  53. br_port_state_names[p->state]);
  54. if (p->br->stp_enabled == BR_KERNEL_STP) {
  55. switch (p->state) {
  56. case BR_STATE_BLOCKING:
  57. p->stp_xstats.transition_blk++;
  58. break;
  59. case BR_STATE_FORWARDING:
  60. p->stp_xstats.transition_fwd++;
  61. break;
  62. }
  63. }
  64. }
  65. u8 br_port_get_stp_state(const struct net_device *dev)
  66. {
  67. struct net_bridge_port *p;
  68. ASSERT_RTNL();
  69. p = br_port_get_rtnl(dev);
  70. if (!p)
  71. return BR_STATE_DISABLED;
  72. return p->state;
  73. }
  74. EXPORT_SYMBOL_GPL(br_port_get_stp_state);
  75. /* called under bridge lock */
  76. struct net_bridge_port *br_get_port(struct net_bridge *br, u16 port_no)
  77. {
  78. struct net_bridge_port *p;
  79. list_for_each_entry_rcu(p, &br->port_list, list,
  80. lockdep_is_held(&br->lock)) {
  81. if (p->port_no == port_no)
  82. return p;
  83. }
  84. return NULL;
  85. }
  86. /* called under bridge lock */
  87. static int br_should_become_root_port(const struct net_bridge_port *p,
  88. u16 root_port)
  89. {
  90. struct net_bridge *br;
  91. struct net_bridge_port *rp;
  92. int t;
  93. br = p->br;
  94. if (p->state == BR_STATE_DISABLED ||
  95. br_is_designated_port(p))
  96. return 0;
  97. if (memcmp(&br->bridge_id, &p->designated_root, 8) <= 0)
  98. return 0;
  99. if (!root_port)
  100. return 1;
  101. rp = br_get_port(br, root_port);
  102. t = memcmp(&p->designated_root, &rp->designated_root, 8);
  103. if (t < 0)
  104. return 1;
  105. else if (t > 0)
  106. return 0;
  107. if (p->designated_cost + p->path_cost <
  108. rp->designated_cost + rp->path_cost)
  109. return 1;
  110. else if (p->designated_cost + p->path_cost >
  111. rp->designated_cost + rp->path_cost)
  112. return 0;
  113. t = memcmp(&p->designated_bridge, &rp->designated_bridge, 8);
  114. if (t < 0)
  115. return 1;
  116. else if (t > 0)
  117. return 0;
  118. if (p->designated_port < rp->designated_port)
  119. return 1;
  120. else if (p->designated_port > rp->designated_port)
  121. return 0;
  122. if (p->port_id < rp->port_id)
  123. return 1;
  124. return 0;
  125. }
  126. static void br_root_port_block(const struct net_bridge *br,
  127. struct net_bridge_port *p)
  128. {
  129. br_notice(br, "port %u(%s) tried to become root port (blocked)",
  130. (unsigned int) p->port_no, p->dev->name);
  131. br_set_state(p, BR_STATE_LISTENING);
  132. br_ifinfo_notify(RTM_NEWLINK, NULL, p);
  133. if (br->forward_delay > 0)
  134. mod_timer(&p->forward_delay_timer, jiffies + br->forward_delay);
  135. }
  136. /* called under bridge lock */
  137. static void br_root_selection(struct net_bridge *br)
  138. {
  139. struct net_bridge_port *p;
  140. u16 root_port = 0;
  141. list_for_each_entry(p, &br->port_list, list) {
  142. if (!br_should_become_root_port(p, root_port))
  143. continue;
  144. if (p->flags & BR_ROOT_BLOCK)
  145. br_root_port_block(br, p);
  146. else
  147. root_port = p->port_no;
  148. }
  149. br->root_port = root_port;
  150. if (!root_port) {
  151. br->designated_root = br->bridge_id;
  152. br->root_path_cost = 0;
  153. } else {
  154. p = br_get_port(br, root_port);
  155. br->designated_root = p->designated_root;
  156. br->root_path_cost = p->designated_cost + p->path_cost;
  157. }
  158. }
  159. /* called under bridge lock */
  160. void br_become_root_bridge(struct net_bridge *br)
  161. {
  162. br->max_age = br->bridge_max_age;
  163. br->hello_time = br->bridge_hello_time;
  164. br->forward_delay = br->bridge_forward_delay;
  165. br_topology_change_detection(br);
  166. del_timer(&br->tcn_timer);
  167. if (br->dev->flags & IFF_UP) {
  168. br_config_bpdu_generation(br);
  169. mod_timer(&br->hello_timer, jiffies + br->hello_time);
  170. }
  171. }
  172. /* called under bridge lock */
  173. void br_transmit_config(struct net_bridge_port *p)
  174. {
  175. struct br_config_bpdu bpdu;
  176. struct net_bridge *br;
  177. if (timer_pending(&p->hold_timer)) {
  178. p->config_pending = 1;
  179. return;
  180. }
  181. br = p->br;
  182. bpdu.topology_change = br->topology_change;
  183. bpdu.topology_change_ack = p->topology_change_ack;
  184. bpdu.root = br->designated_root;
  185. bpdu.root_path_cost = br->root_path_cost;
  186. bpdu.bridge_id = br->bridge_id;
  187. bpdu.port_id = p->port_id;
  188. if (br_is_root_bridge(br))
  189. bpdu.message_age = 0;
  190. else {
  191. struct net_bridge_port *root
  192. = br_get_port(br, br->root_port);
  193. bpdu.message_age = (jiffies - root->designated_age)
  194. + MESSAGE_AGE_INCR;
  195. }
  196. bpdu.max_age = br->max_age;
  197. bpdu.hello_time = br->hello_time;
  198. bpdu.forward_delay = br->forward_delay;
  199. if (bpdu.message_age < br->max_age) {
  200. br_send_config_bpdu(p, &bpdu);
  201. p->topology_change_ack = 0;
  202. p->config_pending = 0;
  203. if (p->br->stp_enabled == BR_KERNEL_STP)
  204. mod_timer(&p->hold_timer,
  205. round_jiffies(jiffies + BR_HOLD_TIME));
  206. }
  207. }
  208. /* called under bridge lock */
  209. static void br_record_config_information(struct net_bridge_port *p,
  210. const struct br_config_bpdu *bpdu)
  211. {
  212. p->designated_root = bpdu->root;
  213. p->designated_cost = bpdu->root_path_cost;
  214. p->designated_bridge = bpdu->bridge_id;
  215. p->designated_port = bpdu->port_id;
  216. p->designated_age = jiffies - bpdu->message_age;
  217. mod_timer(&p->message_age_timer, jiffies
  218. + (bpdu->max_age - bpdu->message_age));
  219. }
  220. /* called under bridge lock */
  221. static void br_record_config_timeout_values(struct net_bridge *br,
  222. const struct br_config_bpdu *bpdu)
  223. {
  224. br->max_age = bpdu->max_age;
  225. br->hello_time = bpdu->hello_time;
  226. br->forward_delay = bpdu->forward_delay;
  227. __br_set_topology_change(br, bpdu->topology_change);
  228. }
  229. /* called under bridge lock */
  230. void br_transmit_tcn(struct net_bridge *br)
  231. {
  232. struct net_bridge_port *p;
  233. p = br_get_port(br, br->root_port);
  234. if (p)
  235. br_send_tcn_bpdu(p);
  236. else
  237. br_notice(br, "root port %u not found for topology notice\n",
  238. br->root_port);
  239. }
  240. /* called under bridge lock */
  241. static int br_should_become_designated_port(const struct net_bridge_port *p)
  242. {
  243. struct net_bridge *br;
  244. int t;
  245. br = p->br;
  246. if (br_is_designated_port(p))
  247. return 1;
  248. if (memcmp(&p->designated_root, &br->designated_root, 8))
  249. return 1;
  250. if (br->root_path_cost < p->designated_cost)
  251. return 1;
  252. else if (br->root_path_cost > p->designated_cost)
  253. return 0;
  254. t = memcmp(&br->bridge_id, &p->designated_bridge, 8);
  255. if (t < 0)
  256. return 1;
  257. else if (t > 0)
  258. return 0;
  259. if (p->port_id < p->designated_port)
  260. return 1;
  261. return 0;
  262. }
  263. /* called under bridge lock */
  264. static void br_designated_port_selection(struct net_bridge *br)
  265. {
  266. struct net_bridge_port *p;
  267. list_for_each_entry(p, &br->port_list, list) {
  268. if (p->state != BR_STATE_DISABLED &&
  269. br_should_become_designated_port(p))
  270. br_become_designated_port(p);
  271. }
  272. }
  273. /* called under bridge lock */
  274. static int br_supersedes_port_info(const struct net_bridge_port *p,
  275. const struct br_config_bpdu *bpdu)
  276. {
  277. int t;
  278. t = memcmp(&bpdu->root, &p->designated_root, 8);
  279. if (t < 0)
  280. return 1;
  281. else if (t > 0)
  282. return 0;
  283. if (bpdu->root_path_cost < p->designated_cost)
  284. return 1;
  285. else if (bpdu->root_path_cost > p->designated_cost)
  286. return 0;
  287. t = memcmp(&bpdu->bridge_id, &p->designated_bridge, 8);
  288. if (t < 0)
  289. return 1;
  290. else if (t > 0)
  291. return 0;
  292. if (memcmp(&bpdu->bridge_id, &p->br->bridge_id, 8))
  293. return 1;
  294. if (bpdu->port_id <= p->designated_port)
  295. return 1;
  296. return 0;
  297. }
  298. /* called under bridge lock */
  299. static void br_topology_change_acknowledged(struct net_bridge *br)
  300. {
  301. br->topology_change_detected = 0;
  302. del_timer(&br->tcn_timer);
  303. }
  304. /* called under bridge lock */
  305. void br_topology_change_detection(struct net_bridge *br)
  306. {
  307. int isroot = br_is_root_bridge(br);
  308. if (br->stp_enabled != BR_KERNEL_STP)
  309. return;
  310. br_info(br, "topology change detected, %s\n",
  311. isroot ? "propagating" : "sending tcn bpdu");
  312. if (isroot) {
  313. __br_set_topology_change(br, 1);
  314. mod_timer(&br->topology_change_timer, jiffies
  315. + br->bridge_forward_delay + br->bridge_max_age);
  316. } else if (!br->topology_change_detected) {
  317. br_transmit_tcn(br);
  318. mod_timer(&br->tcn_timer, jiffies + br->bridge_hello_time);
  319. }
  320. br->topology_change_detected = 1;
  321. }
  322. /* called under bridge lock */
  323. void br_config_bpdu_generation(struct net_bridge *br)
  324. {
  325. struct net_bridge_port *p;
  326. list_for_each_entry(p, &br->port_list, list) {
  327. if (p->state != BR_STATE_DISABLED &&
  328. br_is_designated_port(p))
  329. br_transmit_config(p);
  330. }
  331. }
  332. /* called under bridge lock */
  333. static void br_reply(struct net_bridge_port *p)
  334. {
  335. br_transmit_config(p);
  336. }
  337. /* called under bridge lock */
  338. void br_configuration_update(struct net_bridge *br)
  339. {
  340. br_root_selection(br);
  341. br_designated_port_selection(br);
  342. }
  343. /* called under bridge lock */
  344. void br_become_designated_port(struct net_bridge_port *p)
  345. {
  346. struct net_bridge *br;
  347. br = p->br;
  348. p->designated_root = br->designated_root;
  349. p->designated_cost = br->root_path_cost;
  350. p->designated_bridge = br->bridge_id;
  351. p->designated_port = p->port_id;
  352. }
  353. /* called under bridge lock */
  354. static void br_make_blocking(struct net_bridge_port *p)
  355. {
  356. if (p->state != BR_STATE_DISABLED &&
  357. p->state != BR_STATE_BLOCKING) {
  358. if (p->state == BR_STATE_FORWARDING ||
  359. p->state == BR_STATE_LEARNING)
  360. br_topology_change_detection(p->br);
  361. br_set_state(p, BR_STATE_BLOCKING);
  362. br_ifinfo_notify(RTM_NEWLINK, NULL, p);
  363. del_timer(&p->forward_delay_timer);
  364. }
  365. }
  366. /* called under bridge lock */
  367. static void br_make_forwarding(struct net_bridge_port *p)
  368. {
  369. struct net_bridge *br = p->br;
  370. if (p->state != BR_STATE_BLOCKING)
  371. return;
  372. if (br->stp_enabled == BR_NO_STP || br->forward_delay == 0) {
  373. br_set_state(p, BR_STATE_FORWARDING);
  374. br_topology_change_detection(br);
  375. del_timer(&p->forward_delay_timer);
  376. } else if (br->stp_enabled == BR_KERNEL_STP)
  377. br_set_state(p, BR_STATE_LISTENING);
  378. else
  379. br_set_state(p, BR_STATE_LEARNING);
  380. br_ifinfo_notify(RTM_NEWLINK, NULL, p);
  381. if (br->forward_delay != 0)
  382. mod_timer(&p->forward_delay_timer, jiffies + br->forward_delay);
  383. }
  384. /* called under bridge lock */
  385. void br_port_state_selection(struct net_bridge *br)
  386. {
  387. struct net_bridge_port *p;
  388. unsigned int liveports = 0;
  389. list_for_each_entry(p, &br->port_list, list) {
  390. if (p->state == BR_STATE_DISABLED)
  391. continue;
  392. /* Don't change port states if userspace is handling STP */
  393. if (br->stp_enabled != BR_USER_STP) {
  394. if (p->port_no == br->root_port) {
  395. p->config_pending = 0;
  396. p->topology_change_ack = 0;
  397. br_make_forwarding(p);
  398. } else if (br_is_designated_port(p)) {
  399. del_timer(&p->message_age_timer);
  400. br_make_forwarding(p);
  401. } else {
  402. p->config_pending = 0;
  403. p->topology_change_ack = 0;
  404. br_make_blocking(p);
  405. }
  406. }
  407. if (p->state != BR_STATE_BLOCKING)
  408. br_multicast_enable_port(p);
  409. /* Multicast is not disabled for the port when it goes in
  410. * blocking state because the timers will expire and stop by
  411. * themselves without sending more queries.
  412. */
  413. if (p->state == BR_STATE_FORWARDING)
  414. ++liveports;
  415. }
  416. if (liveports == 0)
  417. netif_carrier_off(br->dev);
  418. else
  419. netif_carrier_on(br->dev);
  420. }
  421. /* called under bridge lock */
  422. static void br_topology_change_acknowledge(struct net_bridge_port *p)
  423. {
  424. p->topology_change_ack = 1;
  425. br_transmit_config(p);
  426. }
  427. /* called under bridge lock */
  428. void br_received_config_bpdu(struct net_bridge_port *p,
  429. const struct br_config_bpdu *bpdu)
  430. {
  431. struct net_bridge *br;
  432. int was_root;
  433. p->stp_xstats.rx_bpdu++;
  434. br = p->br;
  435. was_root = br_is_root_bridge(br);
  436. if (br_supersedes_port_info(p, bpdu)) {
  437. br_record_config_information(p, bpdu);
  438. br_configuration_update(br);
  439. br_port_state_selection(br);
  440. if (!br_is_root_bridge(br) && was_root) {
  441. del_timer(&br->hello_timer);
  442. if (br->topology_change_detected) {
  443. del_timer(&br->topology_change_timer);
  444. br_transmit_tcn(br);
  445. mod_timer(&br->tcn_timer,
  446. jiffies + br->bridge_hello_time);
  447. }
  448. }
  449. if (p->port_no == br->root_port) {
  450. br_record_config_timeout_values(br, bpdu);
  451. br_config_bpdu_generation(br);
  452. if (bpdu->topology_change_ack)
  453. br_topology_change_acknowledged(br);
  454. }
  455. } else if (br_is_designated_port(p)) {
  456. br_reply(p);
  457. }
  458. }
  459. /* called under bridge lock */
  460. void br_received_tcn_bpdu(struct net_bridge_port *p)
  461. {
  462. p->stp_xstats.rx_tcn++;
  463. if (br_is_designated_port(p)) {
  464. br_info(p->br, "port %u(%s) received tcn bpdu\n",
  465. (unsigned int) p->port_no, p->dev->name);
  466. br_topology_change_detection(p->br);
  467. br_topology_change_acknowledge(p);
  468. }
  469. }
  470. /* Change bridge STP parameter */
  471. int br_set_hello_time(struct net_bridge *br, unsigned long val)
  472. {
  473. unsigned long t = clock_t_to_jiffies(val);
  474. if (t < BR_MIN_HELLO_TIME || t > BR_MAX_HELLO_TIME)
  475. return -ERANGE;
  476. spin_lock_bh(&br->lock);
  477. br->bridge_hello_time = t;
  478. if (br_is_root_bridge(br))
  479. br->hello_time = br->bridge_hello_time;
  480. spin_unlock_bh(&br->lock);
  481. return 0;
  482. }
  483. int br_set_max_age(struct net_bridge *br, unsigned long val)
  484. {
  485. unsigned long t = clock_t_to_jiffies(val);
  486. if (t < BR_MIN_MAX_AGE || t > BR_MAX_MAX_AGE)
  487. return -ERANGE;
  488. spin_lock_bh(&br->lock);
  489. br->bridge_max_age = t;
  490. if (br_is_root_bridge(br))
  491. br->max_age = br->bridge_max_age;
  492. spin_unlock_bh(&br->lock);
  493. return 0;
  494. }
  495. /* called under bridge lock */
  496. int __set_ageing_time(struct net_device *dev, unsigned long t)
  497. {
  498. struct switchdev_attr attr = {
  499. .orig_dev = dev,
  500. .id = SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME,
  501. .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP | SWITCHDEV_F_DEFER,
  502. .u.ageing_time = jiffies_to_clock_t(t),
  503. };
  504. int err;
  505. err = switchdev_port_attr_set(dev, &attr, NULL);
  506. if (err && err != -EOPNOTSUPP)
  507. return err;
  508. return 0;
  509. }
  510. /* Set time interval that dynamic forwarding entries live
  511. * For pure software bridge, allow values outside the 802.1
  512. * standard specification for special cases:
  513. * 0 - entry never ages (all permanent)
  514. * 1 - entry disappears (no persistence)
  515. *
  516. * Offloaded switch entries maybe more restrictive
  517. */
  518. int br_set_ageing_time(struct net_bridge *br, clock_t ageing_time)
  519. {
  520. unsigned long t = clock_t_to_jiffies(ageing_time);
  521. int err;
  522. err = __set_ageing_time(br->dev, t);
  523. if (err)
  524. return err;
  525. spin_lock_bh(&br->lock);
  526. br->bridge_ageing_time = t;
  527. br->ageing_time = t;
  528. spin_unlock_bh(&br->lock);
  529. mod_delayed_work(system_long_wq, &br->gc_work, 0);
  530. return 0;
  531. }
  532. clock_t br_get_ageing_time(const struct net_device *br_dev)
  533. {
  534. const struct net_bridge *br;
  535. if (!netif_is_bridge_master(br_dev))
  536. return 0;
  537. br = netdev_priv(br_dev);
  538. return jiffies_to_clock_t(br->ageing_time);
  539. }
  540. EXPORT_SYMBOL_GPL(br_get_ageing_time);
  541. /* called under bridge lock */
  542. void __br_set_topology_change(struct net_bridge *br, unsigned char val)
  543. {
  544. unsigned long t;
  545. int err;
  546. if (br->stp_enabled == BR_KERNEL_STP && br->topology_change != val) {
  547. /* On topology change, set the bridge ageing time to twice the
  548. * forward delay. Otherwise, restore its default ageing time.
  549. */
  550. if (val) {
  551. t = 2 * br->forward_delay;
  552. br_debug(br, "decreasing ageing time to %lu\n", t);
  553. } else {
  554. t = br->bridge_ageing_time;
  555. br_debug(br, "restoring ageing time to %lu\n", t);
  556. }
  557. err = __set_ageing_time(br->dev, t);
  558. if (err)
  559. br_warn(br, "error offloading ageing time\n");
  560. else
  561. br->ageing_time = t;
  562. }
  563. br->topology_change = val;
  564. }
  565. void __br_set_forward_delay(struct net_bridge *br, unsigned long t)
  566. {
  567. br->bridge_forward_delay = t;
  568. if (br_is_root_bridge(br))
  569. br->forward_delay = br->bridge_forward_delay;
  570. }
  571. int br_set_forward_delay(struct net_bridge *br, unsigned long val)
  572. {
  573. unsigned long t = clock_t_to_jiffies(val);
  574. int err = -ERANGE;
  575. spin_lock_bh(&br->lock);
  576. if (br->stp_enabled != BR_NO_STP &&
  577. (t < BR_MIN_FORWARD_DELAY || t > BR_MAX_FORWARD_DELAY))
  578. goto unlock;
  579. __br_set_forward_delay(br, t);
  580. err = 0;
  581. unlock:
  582. spin_unlock_bh(&br->lock);
  583. return err;
  584. }