net/bridge/br_if.c

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