br_if.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Userspace interface
  4. * Linux ethernet bridge
  5. *
  6. * Authors:
  7. * Lennert Buytenhek <buytenh@gnu.org>
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/netdevice.h>
  11. #include <linux/etherdevice.h>
  12. #include <linux/netpoll.h>
  13. #include <linux/ethtool.h>
  14. #include <linux/if_arp.h>
  15. #include <linux/module.h>
  16. #include <linux/init.h>
  17. #include <linux/rtnetlink.h>
  18. #include <linux/if_ether.h>
  19. #include <linux/slab.h>
  20. #include <net/dsa.h>
  21. #include <net/sock.h>
  22. #include <linux/if_vlan.h>
  23. #include <net/switchdev.h>
  24. #include <net/net_namespace.h>
  25. #include "br_private.h"
  26. /*
  27. * Determine initial path cost based on speed.
  28. * using recommendations from 802.1d standard
  29. *
  30. * Since driver might sleep need to not be holding any locks.
  31. */
  32. static int port_cost(struct net_device *dev)
  33. {
  34. struct ethtool_link_ksettings ecmd;
  35. if (!__ethtool_get_link_ksettings(dev, &ecmd)) {
  36. switch (ecmd.base.speed) {
  37. case SPEED_10000:
  38. return 2;
  39. case SPEED_1000:
  40. return 4;
  41. case SPEED_100:
  42. return 19;
  43. case SPEED_10:
  44. return 100;
  45. }
  46. }
  47. /* Old silly heuristics based on name */
  48. if (!strncmp(dev->name, "lec", 3))
  49. return 7;
  50. if (!strncmp(dev->name, "plip", 4))
  51. return 2500;
  52. return 100; /* assume old 10Mbps */
  53. }
  54. /* Check for port carrier transitions. */
  55. void br_port_carrier_check(struct net_bridge_port *p, bool *notified)
  56. {
  57. struct net_device *dev = p->dev;
  58. struct net_bridge *br = p->br;
  59. if (!(p->flags & BR_ADMIN_COST) &&
  60. netif_running(dev) && netif_oper_up(dev))
  61. p->path_cost = port_cost(dev);
  62. *notified = false;
  63. if (!netif_running(br->dev))
  64. return;
  65. spin_lock_bh(&br->lock);
  66. if (netif_running(dev) && netif_oper_up(dev)) {
  67. if (p->state == BR_STATE_DISABLED) {
  68. br_stp_enable_port(p);
  69. *notified = true;
  70. }
  71. } else {
  72. if (p->state != BR_STATE_DISABLED) {
  73. br_stp_disable_port(p);
  74. *notified = true;
  75. }
  76. }
  77. spin_unlock_bh(&br->lock);
  78. }
  79. static void br_port_set_promisc(struct net_bridge_port *p)
  80. {
  81. int err = 0;
  82. if (br_promisc_port(p))
  83. return;
  84. err = dev_set_promiscuity(p->dev, 1);
  85. if (err)
  86. return;
  87. br_fdb_unsync_static(p->br, p);
  88. p->flags |= BR_PROMISC;
  89. }
  90. static void br_port_clear_promisc(struct net_bridge_port *p)
  91. {
  92. int err;
  93. /* Check if the port is already non-promisc or if it doesn't
  94. * support UNICAST filtering. Without unicast filtering support
  95. * we'll end up re-enabling promisc mode anyway, so just check for
  96. * it here.
  97. */
  98. if (!br_promisc_port(p) || !(p->dev->priv_flags & IFF_UNICAST_FLT))
  99. return;
  100. /* Since we'll be clearing the promisc mode, program the port
  101. * first so that we don't have interruption in traffic.
  102. */
  103. err = br_fdb_sync_static(p->br, p);
  104. if (err)
  105. return;
  106. dev_set_promiscuity(p->dev, -1);
  107. p->flags &= ~BR_PROMISC;
  108. }
  109. /* When a port is added or removed or when certain port flags
  110. * change, this function is called to automatically manage
  111. * promiscuity setting of all the bridge ports. We are always called
  112. * under RTNL so can skip using rcu primitives.
  113. */
  114. void br_manage_promisc(struct net_bridge *br)
  115. {
  116. struct net_bridge_port *p;
  117. bool set_all = false;
  118. /* If vlan filtering is disabled or bridge interface is placed
  119. * into promiscuous mode, place all ports in promiscuous mode.
  120. */
  121. if ((br->dev->flags & IFF_PROMISC) || !br_vlan_enabled(br->dev))
  122. set_all = true;
  123. list_for_each_entry(p, &br->port_list, list) {
  124. if (set_all) {
  125. br_port_set_promisc(p);
  126. } else {
  127. /* If the number of auto-ports is <= 1, then all other
  128. * ports will have their output configuration
  129. * statically specified through fdbs. Since ingress
  130. * on the auto-port becomes forwarding/egress to other
  131. * ports and egress configuration is statically known,
  132. * we can say that ingress configuration of the
  133. * auto-port is also statically known.
  134. * This lets us disable promiscuous mode and write
  135. * this config to hw.
  136. */
  137. if (br->auto_cnt == 0 ||
  138. (br->auto_cnt == 1 && br_auto_port(p)))
  139. br_port_clear_promisc(p);
  140. else
  141. br_port_set_promisc(p);
  142. }
  143. }
  144. }
  145. int nbp_backup_change(struct net_bridge_port *p,
  146. struct net_device *backup_dev)
  147. {
  148. struct net_bridge_port *old_backup = rtnl_dereference(p->backup_port);
  149. struct net_bridge_port *backup_p = NULL;
  150. ASSERT_RTNL();
  151. if (backup_dev) {
  152. if (!netif_is_bridge_port(backup_dev))
  153. return -ENOENT;
  154. backup_p = br_port_get_rtnl(backup_dev);
  155. if (backup_p->br != p->br)
  156. return -EINVAL;
  157. }
  158. if (p == backup_p)
  159. return -EINVAL;
  160. if (old_backup == backup_p)
  161. return 0;
  162. /* if the backup link is already set, clear it */
  163. if (old_backup)
  164. old_backup->backup_redirected_cnt--;
  165. if (backup_p)
  166. backup_p->backup_redirected_cnt++;
  167. rcu_assign_pointer(p->backup_port, backup_p);
  168. return 0;
  169. }
  170. static void nbp_backup_clear(struct net_bridge_port *p)
  171. {
  172. nbp_backup_change(p, NULL);
  173. if (p->backup_redirected_cnt) {
  174. struct net_bridge_port *cur_p;
  175. list_for_each_entry(cur_p, &p->br->port_list, list) {
  176. struct net_bridge_port *backup_p;
  177. backup_p = rtnl_dereference(cur_p->backup_port);
  178. if (backup_p == p)
  179. nbp_backup_change(cur_p, NULL);
  180. }
  181. }
  182. WARN_ON(rcu_access_pointer(p->backup_port) || p->backup_redirected_cnt);
  183. }
  184. static void nbp_update_port_count(struct net_bridge *br)
  185. {
  186. struct net_bridge_port *p;
  187. u32 cnt = 0;
  188. list_for_each_entry(p, &br->port_list, list) {
  189. if (br_auto_port(p))
  190. cnt++;
  191. }
  192. if (br->auto_cnt != cnt) {
  193. br->auto_cnt = cnt;
  194. br_manage_promisc(br);
  195. }
  196. }
  197. static void nbp_delete_promisc(struct net_bridge_port *p)
  198. {
  199. /* If port is currently promiscuous, unset promiscuity.
  200. * Otherwise, it is a static port so remove all addresses
  201. * from it.
  202. */
  203. dev_set_allmulti(p->dev, -1);
  204. if (br_promisc_port(p))
  205. dev_set_promiscuity(p->dev, -1);
  206. else
  207. br_fdb_unsync_static(p->br, p);
  208. }
  209. static void release_nbp(struct kobject *kobj)
  210. {
  211. struct net_bridge_port *p
  212. = container_of(kobj, struct net_bridge_port, kobj);
  213. kfree(p);
  214. }
  215. static void brport_get_ownership(struct kobject *kobj, kuid_t *uid, kgid_t *gid)
  216. {
  217. struct net_bridge_port *p = kobj_to_brport(kobj);
  218. net_ns_get_ownership(dev_net(p->dev), uid, gid);
  219. }
  220. static struct kobj_type brport_ktype = {
  221. #ifdef CONFIG_SYSFS
  222. .sysfs_ops = &brport_sysfs_ops,
  223. #endif
  224. .release = release_nbp,
  225. .get_ownership = brport_get_ownership,
  226. };
  227. static void destroy_nbp(struct net_bridge_port *p)
  228. {
  229. struct net_device *dev = p->dev;
  230. p->br = NULL;
  231. p->dev = NULL;
  232. dev_put(dev);
  233. kobject_put(&p->kobj);
  234. }
  235. static void destroy_nbp_rcu(struct rcu_head *head)
  236. {
  237. struct net_bridge_port *p =
  238. container_of(head, struct net_bridge_port, rcu);
  239. destroy_nbp(p);
  240. }
  241. static unsigned get_max_headroom(struct net_bridge *br)
  242. {
  243. unsigned max_headroom = 0;
  244. struct net_bridge_port *p;
  245. list_for_each_entry(p, &br->port_list, list) {
  246. unsigned dev_headroom = netdev_get_fwd_headroom(p->dev);
  247. if (dev_headroom > max_headroom)
  248. max_headroom = dev_headroom;
  249. }
  250. return max_headroom;
  251. }
  252. static void update_headroom(struct net_bridge *br, int new_hr)
  253. {
  254. struct net_bridge_port *p;
  255. list_for_each_entry(p, &br->port_list, list)
  256. netdev_set_rx_headroom(p->dev, new_hr);
  257. br->dev->needed_headroom = new_hr;
  258. }
  259. /* Delete port(interface) from bridge is done in two steps.
  260. * via RCU. First step, marks device as down. That deletes
  261. * all the timers and stops new packets from flowing through.
  262. *
  263. * Final cleanup doesn't occur until after all CPU's finished
  264. * processing packets.
  265. *
  266. * Protected from multiple admin operations by RTNL mutex
  267. */
  268. static void del_nbp(struct net_bridge_port *p)
  269. {
  270. struct net_bridge *br = p->br;
  271. struct net_device *dev = p->dev;
  272. sysfs_remove_link(br->ifobj, p->dev->name);
  273. nbp_delete_promisc(p);
  274. spin_lock_bh(&br->lock);
  275. br_stp_disable_port(p);
  276. spin_unlock_bh(&br->lock);
  277. br_mrp_port_del(br, p);
  278. br_ifinfo_notify(RTM_DELLINK, NULL, p);
  279. list_del_rcu(&p->list);
  280. if (netdev_get_fwd_headroom(dev) == br->dev->needed_headroom)
  281. update_headroom(br, get_max_headroom(br));
  282. netdev_reset_rx_headroom(dev);
  283. nbp_vlan_flush(p);
  284. br_fdb_delete_by_port(br, p, 0, 1);
  285. switchdev_deferred_process();
  286. nbp_backup_clear(p);
  287. nbp_update_port_count(br);
  288. netdev_upper_dev_unlink(dev, br->dev);
  289. dev->priv_flags &= ~IFF_BRIDGE_PORT;
  290. netdev_rx_handler_unregister(dev);
  291. br_multicast_del_port(p);
  292. kobject_uevent(&p->kobj, KOBJ_REMOVE);
  293. kobject_del(&p->kobj);
  294. br_netpoll_disable(p);
  295. call_rcu(&p->rcu, destroy_nbp_rcu);
  296. }
  297. /* Delete bridge device */
  298. void br_dev_delete(struct net_device *dev, struct list_head *head)
  299. {
  300. struct net_bridge *br = netdev_priv(dev);
  301. struct net_bridge_port *p, *n;
  302. list_for_each_entry_safe(p, n, &br->port_list, list) {
  303. del_nbp(p);
  304. }
  305. br_recalculate_neigh_suppress_enabled(br);
  306. br_fdb_delete_by_port(br, NULL, 0, 1);
  307. cancel_delayed_work_sync(&br->gc_work);
  308. br_sysfs_delbr(br->dev);
  309. unregister_netdevice_queue(br->dev, head);
  310. }
  311. /* find an available port number */
  312. static int find_portno(struct net_bridge *br)
  313. {
  314. int index;
  315. struct net_bridge_port *p;
  316. unsigned long *inuse;
  317. inuse = bitmap_zalloc(BR_MAX_PORTS, GFP_KERNEL);
  318. if (!inuse)
  319. return -ENOMEM;
  320. set_bit(0, inuse); /* zero is reserved */
  321. list_for_each_entry(p, &br->port_list, list) {
  322. set_bit(p->port_no, inuse);
  323. }
  324. index = find_first_zero_bit(inuse, BR_MAX_PORTS);
  325. bitmap_free(inuse);
  326. return (index >= BR_MAX_PORTS) ? -EXFULL : index;
  327. }
  328. /* called with RTNL but without bridge lock */
  329. static struct net_bridge_port *new_nbp(struct net_bridge *br,
  330. struct net_device *dev)
  331. {
  332. struct net_bridge_port *p;
  333. int index, err;
  334. index = find_portno(br);
  335. if (index < 0)
  336. return ERR_PTR(index);
  337. p = kzalloc(sizeof(*p), GFP_KERNEL);
  338. if (p == NULL)
  339. return ERR_PTR(-ENOMEM);
  340. p->br = br;
  341. dev_hold(dev);
  342. p->dev = dev;
  343. p->path_cost = port_cost(dev);
  344. p->priority = 0x8000 >> BR_PORT_BITS;
  345. p->port_no = index;
  346. p->flags = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
  347. br_init_port(p);
  348. br_set_state(p, BR_STATE_DISABLED);
  349. br_stp_port_timer_init(p);
  350. err = br_multicast_add_port(p);
  351. if (err) {
  352. dev_put(dev);
  353. kfree(p);
  354. p = ERR_PTR(err);
  355. }
  356. return p;
  357. }
  358. int br_add_bridge(struct net *net, const char *name)
  359. {
  360. struct net_device *dev;
  361. int res;
  362. dev = alloc_netdev(sizeof(struct net_bridge), name, NET_NAME_UNKNOWN,
  363. br_dev_setup);
  364. if (!dev)
  365. return -ENOMEM;
  366. dev_net_set(dev, net);
  367. dev->rtnl_link_ops = &br_link_ops;
  368. res = register_netdev(dev);
  369. if (res)
  370. free_netdev(dev);
  371. return res;
  372. }
  373. int br_del_bridge(struct net *net, const char *name)
  374. {
  375. struct net_device *dev;
  376. int ret = 0;
  377. rtnl_lock();
  378. dev = __dev_get_by_name(net, name);
  379. if (dev == NULL)
  380. ret = -ENXIO; /* Could not find device */
  381. else if (!(dev->priv_flags & IFF_EBRIDGE)) {
  382. /* Attempt to delete non bridge device! */
  383. ret = -EPERM;
  384. }
  385. else if (dev->flags & IFF_UP) {
  386. /* Not shutdown yet. */
  387. ret = -EBUSY;
  388. }
  389. else
  390. br_dev_delete(dev, NULL);
  391. rtnl_unlock();
  392. return ret;
  393. }
  394. /* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
  395. static int br_mtu_min(const struct net_bridge *br)
  396. {
  397. const struct net_bridge_port *p;
  398. int ret_mtu = 0;
  399. list_for_each_entry(p, &br->port_list, list)
  400. if (!ret_mtu || ret_mtu > p->dev->mtu)
  401. ret_mtu = p->dev->mtu;
  402. return ret_mtu ? ret_mtu : ETH_DATA_LEN;
  403. }
  404. void br_mtu_auto_adjust(struct net_bridge *br)
  405. {
  406. ASSERT_RTNL();
  407. /* if the bridge MTU was manually configured don't mess with it */
  408. if (br_opt_get(br, BROPT_MTU_SET_BY_USER))
  409. return;
  410. /* change to the minimum MTU and clear the flag which was set by
  411. * the bridge ndo_change_mtu callback
  412. */
  413. dev_set_mtu(br->dev, br_mtu_min(br));
  414. br_opt_toggle(br, BROPT_MTU_SET_BY_USER, false);
  415. }
  416. static void br_set_gso_limits(struct net_bridge *br)
  417. {
  418. unsigned int gso_max_size = GSO_MAX_SIZE;
  419. u16 gso_max_segs = GSO_MAX_SEGS;
  420. const struct net_bridge_port *p;
  421. list_for_each_entry(p, &br->port_list, list) {
  422. gso_max_size = min(gso_max_size, p->dev->gso_max_size);
  423. gso_max_segs = min(gso_max_segs, p->dev->gso_max_segs);
  424. }
  425. br->dev->gso_max_size = gso_max_size;
  426. br->dev->gso_max_segs = gso_max_segs;
  427. }
  428. /*
  429. * Recomputes features using slave's features
  430. */
  431. netdev_features_t br_features_recompute(struct net_bridge *br,
  432. netdev_features_t features)
  433. {
  434. struct net_bridge_port *p;
  435. netdev_features_t mask;
  436. if (list_empty(&br->port_list))
  437. return features;
  438. mask = features;
  439. features &= ~NETIF_F_ONE_FOR_ALL;
  440. list_for_each_entry(p, &br->port_list, list) {
  441. features = netdev_increment_features(features,
  442. p->dev->features, mask);
  443. }
  444. features = netdev_add_tso_features(features, mask);
  445. return features;
  446. }
  447. /* called with RTNL */
  448. int br_add_if(struct net_bridge *br, struct net_device *dev,
  449. struct netlink_ext_ack *extack)
  450. {
  451. struct net_bridge_port *p;
  452. int err = 0;
  453. unsigned br_hr, dev_hr;
  454. bool changed_addr, fdb_synced = false;
  455. /* Don't allow bridging non-ethernet like devices. */
  456. if ((dev->flags & IFF_LOOPBACK) ||
  457. dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN ||
  458. !is_valid_ether_addr(dev->dev_addr))
  459. return -EINVAL;
  460. /* Also don't allow bridging of net devices that are DSA masters, since
  461. * the bridge layer rx_handler prevents the DSA fake ethertype handler
  462. * to be invoked, so we don't get the chance to strip off and parse the
  463. * DSA switch tag protocol header (the bridge layer just returns
  464. * RX_HANDLER_CONSUMED, stopping RX processing for these frames).
  465. * The only case where that would not be an issue is when bridging can
  466. * already be offloaded, such as when the DSA master is itself a DSA
  467. * or plain switchdev port, and is bridged only with other ports from
  468. * the same hardware device.
  469. */
  470. if (netdev_uses_dsa(dev)) {
  471. list_for_each_entry(p, &br->port_list, list) {
  472. if (!netdev_port_same_parent_id(dev, p->dev)) {
  473. NL_SET_ERR_MSG(extack,
  474. "Cannot do software bridging with a DSA master");
  475. return -EINVAL;
  476. }
  477. }
  478. }
  479. /* No bridging of bridges */
  480. if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit) {
  481. NL_SET_ERR_MSG(extack,
  482. "Can not enslave a bridge to a bridge");
  483. return -ELOOP;
  484. }
  485. /* Device has master upper dev */
  486. if (netdev_master_upper_dev_get(dev))
  487. return -EBUSY;
  488. /* No bridging devices that dislike that (e.g. wireless) */
  489. if (dev->priv_flags & IFF_DONT_BRIDGE) {
  490. NL_SET_ERR_MSG(extack,
  491. "Device does not allow enslaving to a bridge");
  492. return -EOPNOTSUPP;
  493. }
  494. p = new_nbp(br, dev);
  495. if (IS_ERR(p))
  496. return PTR_ERR(p);
  497. call_netdevice_notifiers(NETDEV_JOIN, dev);
  498. err = dev_set_allmulti(dev, 1);
  499. if (err) {
  500. br_multicast_del_port(p);
  501. kfree(p); /* kobject not yet init'd, manually free */
  502. goto err1;
  503. }
  504. err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
  505. SYSFS_BRIDGE_PORT_ATTR);
  506. if (err)
  507. goto err2;
  508. err = br_sysfs_addif(p);
  509. if (err)
  510. goto err2;
  511. err = br_netpoll_enable(p);
  512. if (err)
  513. goto err3;
  514. err = netdev_rx_handler_register(dev, br_get_rx_handler(dev), p);
  515. if (err)
  516. goto err4;
  517. dev->priv_flags |= IFF_BRIDGE_PORT;
  518. err = netdev_master_upper_dev_link(dev, br->dev, NULL, NULL, extack);
  519. if (err)
  520. goto err5;
  521. err = nbp_switchdev_mark_set(p);
  522. if (err)
  523. goto err6;
  524. dev_disable_lro(dev);
  525. list_add_rcu(&p->list, &br->port_list);
  526. nbp_update_port_count(br);
  527. if (!br_promisc_port(p) && (p->dev->priv_flags & IFF_UNICAST_FLT)) {
  528. /* When updating the port count we also update all ports'
  529. * promiscuous mode.
  530. * A port leaving promiscuous mode normally gets the bridge's
  531. * fdb synced to the unicast filter (if supported), however,
  532. * `br_port_clear_promisc` does not distinguish between
  533. * non-promiscuous ports and *new* ports, so we need to
  534. * sync explicitly here.
  535. */
  536. fdb_synced = br_fdb_sync_static(br, p) == 0;
  537. if (!fdb_synced)
  538. netdev_err(dev, "failed to sync bridge static fdb addresses to this port\n");
  539. }
  540. netdev_update_features(br->dev);
  541. br_hr = br->dev->needed_headroom;
  542. dev_hr = netdev_get_fwd_headroom(dev);
  543. if (br_hr < dev_hr)
  544. update_headroom(br, dev_hr);
  545. else
  546. netdev_set_rx_headroom(dev, br_hr);
  547. if (br_fdb_insert(br, p, dev->dev_addr, 0))
  548. netdev_err(dev, "failed insert local address bridge forwarding table\n");
  549. if (br->dev->addr_assign_type != NET_ADDR_SET) {
  550. /* Ask for permission to use this MAC address now, even if we
  551. * don't end up choosing it below.
  552. */
  553. err = dev_pre_changeaddr_notify(br->dev, dev->dev_addr, extack);
  554. if (err)
  555. goto err7;
  556. }
  557. err = nbp_vlan_init(p, extack);
  558. if (err) {
  559. netdev_err(dev, "failed to initialize vlan filtering on this port\n");
  560. goto err7;
  561. }
  562. spin_lock_bh(&br->lock);
  563. changed_addr = br_stp_recalculate_bridge_id(br);
  564. if (netif_running(dev) && netif_oper_up(dev) &&
  565. (br->dev->flags & IFF_UP))
  566. br_stp_enable_port(p);
  567. spin_unlock_bh(&br->lock);
  568. br_ifinfo_notify(RTM_NEWLINK, NULL, p);
  569. if (changed_addr)
  570. call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
  571. br_mtu_auto_adjust(br);
  572. br_set_gso_limits(br);
  573. kobject_uevent(&p->kobj, KOBJ_ADD);
  574. return 0;
  575. err7:
  576. if (fdb_synced)
  577. br_fdb_unsync_static(br, p);
  578. list_del_rcu(&p->list);
  579. br_fdb_delete_by_port(br, p, 0, 1);
  580. nbp_update_port_count(br);
  581. err6:
  582. netdev_upper_dev_unlink(dev, br->dev);
  583. err5:
  584. dev->priv_flags &= ~IFF_BRIDGE_PORT;
  585. netdev_rx_handler_unregister(dev);
  586. err4:
  587. br_netpoll_disable(p);
  588. err3:
  589. sysfs_remove_link(br->ifobj, p->dev->name);
  590. err2:
  591. br_multicast_del_port(p);
  592. kobject_put(&p->kobj);
  593. dev_set_allmulti(dev, -1);
  594. err1:
  595. dev_put(dev);
  596. return err;
  597. }
  598. /* called with RTNL */
  599. int br_del_if(struct net_bridge *br, struct net_device *dev)
  600. {
  601. struct net_bridge_port *p;
  602. bool changed_addr;
  603. p = br_port_get_rtnl(dev);
  604. if (!p || p->br != br)
  605. return -EINVAL;
  606. /* Since more than one interface can be attached to a bridge,
  607. * there still maybe an alternate path for netconsole to use;
  608. * therefore there is no reason for a NETDEV_RELEASE event.
  609. */
  610. del_nbp(p);
  611. br_mtu_auto_adjust(br);
  612. br_set_gso_limits(br);
  613. spin_lock_bh(&br->lock);
  614. changed_addr = br_stp_recalculate_bridge_id(br);
  615. spin_unlock_bh(&br->lock);
  616. if (changed_addr)
  617. call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
  618. netdev_update_features(br->dev);
  619. return 0;
  620. }
  621. void br_port_flags_change(struct net_bridge_port *p, unsigned long mask)
  622. {
  623. struct net_bridge *br = p->br;
  624. if (mask & BR_AUTO_MASK)
  625. nbp_update_port_count(br);
  626. if (mask & BR_NEIGH_SUPPRESS)
  627. br_recalculate_neigh_suppress_enabled(br);
  628. }
  629. bool br_port_flag_is_set(const struct net_device *dev, unsigned long flag)
  630. {
  631. struct net_bridge_port *p;
  632. p = br_port_get_rtnl_rcu(dev);
  633. if (!p)
  634. return false;
  635. return p->flags & flag;
  636. }
  637. EXPORT_SYMBOL_GPL(br_port_flag_is_set);