br_device.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Device handling code
  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/netpoll.h>
  12. #include <linux/etherdevice.h>
  13. #include <linux/ethtool.h>
  14. #include <linux/list.h>
  15. #include <linux/netfilter_bridge.h>
  16. #include <linux/uaccess.h>
  17. #include "br_private.h"
  18. #define COMMON_FEATURES (NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | \
  19. NETIF_F_GSO_MASK | NETIF_F_HW_CSUM)
  20. const struct nf_br_ops __rcu *nf_br_ops __read_mostly;
  21. EXPORT_SYMBOL_GPL(nf_br_ops);
  22. /* net device transmit always called with BH disabled */
  23. netdev_tx_t br_dev_xmit(struct sk_buff *skb, struct net_device *dev)
  24. {
  25. struct net_bridge *br = netdev_priv(dev);
  26. struct net_bridge_fdb_entry *dst;
  27. struct net_bridge_mdb_entry *mdst;
  28. struct pcpu_sw_netstats *brstats = this_cpu_ptr(br->stats);
  29. const struct nf_br_ops *nf_ops;
  30. u8 state = BR_STATE_FORWARDING;
  31. const unsigned char *dest;
  32. u16 vid = 0;
  33. memset(skb->cb, 0, sizeof(struct br_input_skb_cb));
  34. rcu_read_lock();
  35. nf_ops = rcu_dereference(nf_br_ops);
  36. if (nf_ops && nf_ops->br_dev_xmit_hook(skb)) {
  37. rcu_read_unlock();
  38. return NETDEV_TX_OK;
  39. }
  40. u64_stats_update_begin(&brstats->syncp);
  41. brstats->tx_packets++;
  42. brstats->tx_bytes += skb->len;
  43. u64_stats_update_end(&brstats->syncp);
  44. br_switchdev_frame_unmark(skb);
  45. BR_INPUT_SKB_CB(skb)->brdev = dev;
  46. BR_INPUT_SKB_CB(skb)->frag_max_size = 0;
  47. skb_reset_mac_header(skb);
  48. skb_pull(skb, ETH_HLEN);
  49. if (!br_allowed_ingress(br, br_vlan_group_rcu(br), skb, &vid, &state))
  50. goto out;
  51. if (IS_ENABLED(CONFIG_INET) &&
  52. (eth_hdr(skb)->h_proto == htons(ETH_P_ARP) ||
  53. eth_hdr(skb)->h_proto == htons(ETH_P_RARP)) &&
  54. br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED)) {
  55. br_do_proxy_suppress_arp(skb, br, vid, NULL);
  56. } else if (IS_ENABLED(CONFIG_IPV6) &&
  57. skb->protocol == htons(ETH_P_IPV6) &&
  58. br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED) &&
  59. pskb_may_pull(skb, sizeof(struct ipv6hdr) +
  60. sizeof(struct nd_msg)) &&
  61. ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {
  62. struct nd_msg *msg, _msg;
  63. msg = br_is_nd_neigh_msg(skb, &_msg);
  64. if (msg)
  65. br_do_suppress_nd(skb, br, vid, NULL, msg);
  66. }
  67. dest = eth_hdr(skb)->h_dest;
  68. if (is_broadcast_ether_addr(dest)) {
  69. br_flood(br, skb, BR_PKT_BROADCAST, false, true);
  70. } else if (is_multicast_ether_addr(dest)) {
  71. if (unlikely(netpoll_tx_running(dev))) {
  72. br_flood(br, skb, BR_PKT_MULTICAST, false, true);
  73. goto out;
  74. }
  75. if (br_multicast_rcv(br, NULL, skb, vid)) {
  76. kfree_skb(skb);
  77. goto out;
  78. }
  79. mdst = br_mdb_get(br, skb, vid);
  80. if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&
  81. br_multicast_querier_exists(br, eth_hdr(skb)))
  82. br_multicast_flood(mdst, skb, false, true);
  83. else
  84. br_flood(br, skb, BR_PKT_MULTICAST, false, true);
  85. } else if ((dst = br_fdb_find_rcu(br, dest, vid)) != NULL) {
  86. br_forward(dst->dst, skb, false, true);
  87. } else {
  88. br_flood(br, skb, BR_PKT_UNICAST, false, true);
  89. }
  90. out:
  91. rcu_read_unlock();
  92. return NETDEV_TX_OK;
  93. }
  94. static struct lock_class_key bridge_netdev_addr_lock_key;
  95. static void br_set_lockdep_class(struct net_device *dev)
  96. {
  97. lockdep_set_class(&dev->addr_list_lock, &bridge_netdev_addr_lock_key);
  98. }
  99. static int br_dev_init(struct net_device *dev)
  100. {
  101. struct net_bridge *br = netdev_priv(dev);
  102. int err;
  103. br->stats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
  104. if (!br->stats)
  105. return -ENOMEM;
  106. err = br_fdb_hash_init(br);
  107. if (err) {
  108. free_percpu(br->stats);
  109. return err;
  110. }
  111. err = br_mdb_hash_init(br);
  112. if (err) {
  113. free_percpu(br->stats);
  114. br_fdb_hash_fini(br);
  115. return err;
  116. }
  117. err = br_vlan_init(br);
  118. if (err) {
  119. free_percpu(br->stats);
  120. br_mdb_hash_fini(br);
  121. br_fdb_hash_fini(br);
  122. return err;
  123. }
  124. err = br_multicast_init_stats(br);
  125. if (err) {
  126. free_percpu(br->stats);
  127. br_vlan_flush(br);
  128. br_mdb_hash_fini(br);
  129. br_fdb_hash_fini(br);
  130. }
  131. br_set_lockdep_class(dev);
  132. return err;
  133. }
  134. static void br_dev_uninit(struct net_device *dev)
  135. {
  136. struct net_bridge *br = netdev_priv(dev);
  137. br_multicast_dev_del(br);
  138. br_multicast_uninit_stats(br);
  139. br_vlan_flush(br);
  140. br_mdb_hash_fini(br);
  141. br_fdb_hash_fini(br);
  142. free_percpu(br->stats);
  143. }
  144. static int br_dev_open(struct net_device *dev)
  145. {
  146. struct net_bridge *br = netdev_priv(dev);
  147. netdev_update_features(dev);
  148. netif_start_queue(dev);
  149. br_stp_enable_bridge(br);
  150. br_multicast_open(br);
  151. if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
  152. br_multicast_join_snoopers(br);
  153. return 0;
  154. }
  155. static void br_dev_set_multicast_list(struct net_device *dev)
  156. {
  157. }
  158. static void br_dev_change_rx_flags(struct net_device *dev, int change)
  159. {
  160. if (change & IFF_PROMISC)
  161. br_manage_promisc(netdev_priv(dev));
  162. }
  163. static int br_dev_stop(struct net_device *dev)
  164. {
  165. struct net_bridge *br = netdev_priv(dev);
  166. br_stp_disable_bridge(br);
  167. br_multicast_stop(br);
  168. if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
  169. br_multicast_leave_snoopers(br);
  170. netif_stop_queue(dev);
  171. return 0;
  172. }
  173. static void br_get_stats64(struct net_device *dev,
  174. struct rtnl_link_stats64 *stats)
  175. {
  176. struct net_bridge *br = netdev_priv(dev);
  177. netdev_stats_to_stats64(stats, &dev->stats);
  178. dev_fetch_sw_netstats(stats, br->stats);
  179. }
  180. static int br_change_mtu(struct net_device *dev, int new_mtu)
  181. {
  182. struct net_bridge *br = netdev_priv(dev);
  183. dev->mtu = new_mtu;
  184. /* this flag will be cleared if the MTU was automatically adjusted */
  185. br_opt_toggle(br, BROPT_MTU_SET_BY_USER, true);
  186. #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
  187. /* remember the MTU in the rtable for PMTU */
  188. dst_metric_set(&br->fake_rtable.dst, RTAX_MTU, new_mtu);
  189. #endif
  190. return 0;
  191. }
  192. /* Allow setting mac address to any valid ethernet address. */
  193. static int br_set_mac_address(struct net_device *dev, void *p)
  194. {
  195. struct net_bridge *br = netdev_priv(dev);
  196. struct sockaddr *addr = p;
  197. if (!is_valid_ether_addr(addr->sa_data))
  198. return -EADDRNOTAVAIL;
  199. /* dev_set_mac_addr() can be called by a master device on bridge's
  200. * NETDEV_UNREGISTER, but since it's being destroyed do nothing
  201. */
  202. if (dev->reg_state != NETREG_REGISTERED)
  203. return -EBUSY;
  204. spin_lock_bh(&br->lock);
  205. if (!ether_addr_equal(dev->dev_addr, addr->sa_data)) {
  206. /* Mac address will be changed in br_stp_change_bridge_id(). */
  207. br_stp_change_bridge_id(br, addr->sa_data);
  208. }
  209. spin_unlock_bh(&br->lock);
  210. return 0;
  211. }
  212. static void br_getinfo(struct net_device *dev, struct ethtool_drvinfo *info)
  213. {
  214. strlcpy(info->driver, "bridge", sizeof(info->driver));
  215. strlcpy(info->version, BR_VERSION, sizeof(info->version));
  216. strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
  217. strlcpy(info->bus_info, "N/A", sizeof(info->bus_info));
  218. }
  219. static int br_get_link_ksettings(struct net_device *dev,
  220. struct ethtool_link_ksettings *cmd)
  221. {
  222. struct net_bridge *br = netdev_priv(dev);
  223. struct net_bridge_port *p;
  224. cmd->base.duplex = DUPLEX_UNKNOWN;
  225. cmd->base.port = PORT_OTHER;
  226. cmd->base.speed = SPEED_UNKNOWN;
  227. list_for_each_entry(p, &br->port_list, list) {
  228. struct ethtool_link_ksettings ecmd;
  229. struct net_device *pdev = p->dev;
  230. if (!netif_running(pdev) || !netif_oper_up(pdev))
  231. continue;
  232. if (__ethtool_get_link_ksettings(pdev, &ecmd))
  233. continue;
  234. if (ecmd.base.speed == (__u32)SPEED_UNKNOWN)
  235. continue;
  236. if (cmd->base.speed == (__u32)SPEED_UNKNOWN ||
  237. cmd->base.speed < ecmd.base.speed)
  238. cmd->base.speed = ecmd.base.speed;
  239. }
  240. return 0;
  241. }
  242. static netdev_features_t br_fix_features(struct net_device *dev,
  243. netdev_features_t features)
  244. {
  245. struct net_bridge *br = netdev_priv(dev);
  246. return br_features_recompute(br, features);
  247. }
  248. #ifdef CONFIG_NET_POLL_CONTROLLER
  249. static void br_poll_controller(struct net_device *br_dev)
  250. {
  251. }
  252. static void br_netpoll_cleanup(struct net_device *dev)
  253. {
  254. struct net_bridge *br = netdev_priv(dev);
  255. struct net_bridge_port *p;
  256. list_for_each_entry(p, &br->port_list, list)
  257. br_netpoll_disable(p);
  258. }
  259. static int __br_netpoll_enable(struct net_bridge_port *p)
  260. {
  261. struct netpoll *np;
  262. int err;
  263. np = kzalloc(sizeof(*p->np), GFP_KERNEL);
  264. if (!np)
  265. return -ENOMEM;
  266. err = __netpoll_setup(np, p->dev);
  267. if (err) {
  268. kfree(np);
  269. return err;
  270. }
  271. p->np = np;
  272. return err;
  273. }
  274. int br_netpoll_enable(struct net_bridge_port *p)
  275. {
  276. if (!p->br->dev->npinfo)
  277. return 0;
  278. return __br_netpoll_enable(p);
  279. }
  280. static int br_netpoll_setup(struct net_device *dev, struct netpoll_info *ni)
  281. {
  282. struct net_bridge *br = netdev_priv(dev);
  283. struct net_bridge_port *p;
  284. int err = 0;
  285. list_for_each_entry(p, &br->port_list, list) {
  286. if (!p->dev)
  287. continue;
  288. err = __br_netpoll_enable(p);
  289. if (err)
  290. goto fail;
  291. }
  292. out:
  293. return err;
  294. fail:
  295. br_netpoll_cleanup(dev);
  296. goto out;
  297. }
  298. void br_netpoll_disable(struct net_bridge_port *p)
  299. {
  300. struct netpoll *np = p->np;
  301. if (!np)
  302. return;
  303. p->np = NULL;
  304. __netpoll_free(np);
  305. }
  306. #endif
  307. static int br_add_slave(struct net_device *dev, struct net_device *slave_dev,
  308. struct netlink_ext_ack *extack)
  309. {
  310. struct net_bridge *br = netdev_priv(dev);
  311. return br_add_if(br, slave_dev, extack);
  312. }
  313. static int br_del_slave(struct net_device *dev, struct net_device *slave_dev)
  314. {
  315. struct net_bridge *br = netdev_priv(dev);
  316. return br_del_if(br, slave_dev);
  317. }
  318. static const struct ethtool_ops br_ethtool_ops = {
  319. .get_drvinfo = br_getinfo,
  320. .get_link = ethtool_op_get_link,
  321. .get_link_ksettings = br_get_link_ksettings,
  322. };
  323. static const struct net_device_ops br_netdev_ops = {
  324. .ndo_open = br_dev_open,
  325. .ndo_stop = br_dev_stop,
  326. .ndo_init = br_dev_init,
  327. .ndo_uninit = br_dev_uninit,
  328. .ndo_start_xmit = br_dev_xmit,
  329. .ndo_get_stats64 = br_get_stats64,
  330. .ndo_set_mac_address = br_set_mac_address,
  331. .ndo_set_rx_mode = br_dev_set_multicast_list,
  332. .ndo_change_rx_flags = br_dev_change_rx_flags,
  333. .ndo_change_mtu = br_change_mtu,
  334. .ndo_do_ioctl = br_dev_ioctl,
  335. #ifdef CONFIG_NET_POLL_CONTROLLER
  336. .ndo_netpoll_setup = br_netpoll_setup,
  337. .ndo_netpoll_cleanup = br_netpoll_cleanup,
  338. .ndo_poll_controller = br_poll_controller,
  339. #endif
  340. .ndo_add_slave = br_add_slave,
  341. .ndo_del_slave = br_del_slave,
  342. .ndo_fix_features = br_fix_features,
  343. .ndo_fdb_add = br_fdb_add,
  344. .ndo_fdb_del = br_fdb_delete,
  345. .ndo_fdb_dump = br_fdb_dump,
  346. .ndo_fdb_get = br_fdb_get,
  347. .ndo_bridge_getlink = br_getlink,
  348. .ndo_bridge_setlink = br_setlink,
  349. .ndo_bridge_dellink = br_dellink,
  350. .ndo_features_check = passthru_features_check,
  351. };
  352. static struct device_type br_type = {
  353. .name = "bridge",
  354. };
  355. void br_dev_setup(struct net_device *dev)
  356. {
  357. struct net_bridge *br = netdev_priv(dev);
  358. eth_hw_addr_random(dev);
  359. ether_setup(dev);
  360. dev->netdev_ops = &br_netdev_ops;
  361. dev->needs_free_netdev = true;
  362. dev->ethtool_ops = &br_ethtool_ops;
  363. SET_NETDEV_DEVTYPE(dev, &br_type);
  364. dev->priv_flags = IFF_EBRIDGE | IFF_NO_QUEUE;
  365. dev->features = COMMON_FEATURES | NETIF_F_LLTX | NETIF_F_NETNS_LOCAL |
  366. NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
  367. dev->hw_features = COMMON_FEATURES | NETIF_F_HW_VLAN_CTAG_TX |
  368. NETIF_F_HW_VLAN_STAG_TX;
  369. dev->vlan_features = COMMON_FEATURES;
  370. br->dev = dev;
  371. spin_lock_init(&br->lock);
  372. INIT_LIST_HEAD(&br->port_list);
  373. INIT_HLIST_HEAD(&br->fdb_list);
  374. #if IS_ENABLED(CONFIG_BRIDGE_MRP)
  375. INIT_LIST_HEAD(&br->mrp_list);
  376. #endif
  377. spin_lock_init(&br->hash_lock);
  378. br->bridge_id.prio[0] = 0x80;
  379. br->bridge_id.prio[1] = 0x00;
  380. ether_addr_copy(br->group_addr, eth_stp_addr);
  381. br->stp_enabled = BR_NO_STP;
  382. br->group_fwd_mask = BR_GROUPFWD_DEFAULT;
  383. br->group_fwd_mask_required = BR_GROUPFWD_DEFAULT;
  384. br->designated_root = br->bridge_id;
  385. br->bridge_max_age = br->max_age = 20 * HZ;
  386. br->bridge_hello_time = br->hello_time = 2 * HZ;
  387. br->bridge_forward_delay = br->forward_delay = 15 * HZ;
  388. br->bridge_ageing_time = br->ageing_time = BR_DEFAULT_AGEING_TIME;
  389. dev->max_mtu = ETH_MAX_MTU;
  390. br_netfilter_rtable_init(br);
  391. br_stp_timer_init(br);
  392. br_multicast_init(br);
  393. INIT_DELAYED_WORK(&br->gc_work, br_fdb_cleanup);
  394. }