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