net/bridge/br_device.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Device handling code
0004  *  Linux ethernet bridge
0005  *
0006  *  Authors:
0007  *  Lennert Buytenhek       <buytenh@gnu.org>
0008  */
0009
0010 #include <linux/kernel.h>
0011 #include <linux/netdevice.h>
0012 #include <linux/netpoll.h>
0013 #include <linux/etherdevice.h>
0014 #include <linux/ethtool.h>
0015 #include <linux/list.h>
0016 #include <linux/netfilter_bridge.h>
0017
0018 #include <linux/uaccess.h>
0019 #include "br_private.h"
0020
0021 #define COMMON_FEATURES (NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | \
0022              NETIF_F_GSO_MASK | NETIF_F_HW_CSUM)
0023
0024 const struct nf_br_ops __rcu *nf_br_ops __read_mostly;
0025 EXPORT_SYMBOL_GPL(nf_br_ops);
0026
0027 /* net device transmit always called with BH disabled */
0028 netdev_tx_t br_dev_xmit(struct sk_buff *skb, struct net_device *dev)
0029 {
0030     struct net_bridge_mcast_port *pmctx_null = NULL;
0031     struct net_bridge *br = netdev_priv(dev);
0032     struct net_bridge_mcast *brmctx = &br->multicast_ctx;
0033     struct net_bridge_fdb_entry *dst;
0034     struct net_bridge_mdb_entry *mdst;
0035     const struct nf_br_ops *nf_ops;
0036     u8 state = BR_STATE_FORWARDING;
0037     struct net_bridge_vlan *vlan;
0038     const unsigned char *dest;
0039     u16 vid = 0;
0040
0041     memset(skb->cb, 0, sizeof(struct br_input_skb_cb));
0042
0043     rcu_read_lock();
0044     nf_ops = rcu_dereference(nf_br_ops);
0045     if (nf_ops && nf_ops->br_dev_xmit_hook(skb)) {
0046         rcu_read_unlock();
0047         return NETDEV_TX_OK;
0048     }
0049
0050     dev_sw_netstats_tx_add(dev, 1, skb->len);
0051
0052     br_switchdev_frame_unmark(skb);
0053     BR_INPUT_SKB_CB(skb)->brdev = dev;
0054     BR_INPUT_SKB_CB(skb)->frag_max_size = 0;
0055
0056     skb_reset_mac_header(skb);
0057     skb_pull(skb, ETH_HLEN);
0058
0059     if (!br_allowed_ingress(br, br_vlan_group_rcu(br), skb, &vid,
0060                 &state, &vlan))
0061         goto out;
0062
0063     if (IS_ENABLED(CONFIG_INET) &&
0064         (eth_hdr(skb)->h_proto == htons(ETH_P_ARP) ||
0065          eth_hdr(skb)->h_proto == htons(ETH_P_RARP)) &&
0066         br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED)) {
0067         br_do_proxy_suppress_arp(skb, br, vid, NULL);
0068     } else if (IS_ENABLED(CONFIG_IPV6) &&
0069            skb->protocol == htons(ETH_P_IPV6) &&
0070            br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED) &&
0071            pskb_may_pull(skb, sizeof(struct ipv6hdr) +
0072                  sizeof(struct nd_msg)) &&
0073            ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {
0074             struct nd_msg *msg, _msg;
0075
0076             msg = br_is_nd_neigh_msg(skb, &_msg);
0077             if (msg)
0078                 br_do_suppress_nd(skb, br, vid, NULL, msg);
0079     }
0080
0081     dest = eth_hdr(skb)->h_dest;
0082     if (is_broadcast_ether_addr(dest)) {
0083         br_flood(br, skb, BR_PKT_BROADCAST, false, true);
0084     } else if (is_multicast_ether_addr(dest)) {
0085         if (unlikely(netpoll_tx_running(dev))) {
0086             br_flood(br, skb, BR_PKT_MULTICAST, false, true);
0087             goto out;
0088         }
0089         if (br_multicast_rcv(&brmctx, &pmctx_null, vlan, skb, vid)) {
0090             kfree_skb(skb);
0091             goto out;
0092         }
0093
0094         mdst = br_mdb_get(brmctx, skb, vid);
0095         if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&
0096             br_multicast_querier_exists(brmctx, eth_hdr(skb), mdst))
0097             br_multicast_flood(mdst, skb, brmctx, false, true);
0098         else
0099             br_flood(br, skb, BR_PKT_MULTICAST, false, true);
0100     } else if ((dst = br_fdb_find_rcu(br, dest, vid)) != NULL) {
0101         br_forward(dst->dst, skb, false, true);
0102     } else {
0103         br_flood(br, skb, BR_PKT_UNICAST, false, true);
0104     }
0105 out:
0106     rcu_read_unlock();
0107     return NETDEV_TX_OK;
0108 }
0109
0110 static struct lock_class_key bridge_netdev_addr_lock_key;
0111
0112 static void br_set_lockdep_class(struct net_device *dev)
0113 {
0114     lockdep_set_class(&dev->addr_list_lock, &bridge_netdev_addr_lock_key);
0115 }
0116
0117 static int br_dev_init(struct net_device *dev)
0118 {
0119     struct net_bridge *br = netdev_priv(dev);
0120     int err;
0121
0122     dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
0123     if (!dev->tstats)
0124         return -ENOMEM;
0125
0126     err = br_fdb_hash_init(br);
0127     if (err) {
0128         free_percpu(dev->tstats);
0129         return err;
0130     }
0131
0132     err = br_mdb_hash_init(br);
0133     if (err) {
0134         free_percpu(dev->tstats);
0135         br_fdb_hash_fini(br);
0136         return err;
0137     }
0138
0139     err = br_vlan_init(br);
0140     if (err) {
0141         free_percpu(dev->tstats);
0142         br_mdb_hash_fini(br);
0143         br_fdb_hash_fini(br);
0144         return err;
0145     }
0146
0147     err = br_multicast_init_stats(br);
0148     if (err) {
0149         free_percpu(dev->tstats);
0150         br_vlan_flush(br);
0151         br_mdb_hash_fini(br);
0152         br_fdb_hash_fini(br);
0153     }
0154
0155     br_set_lockdep_class(dev);
0156     return err;
0157 }
0158
0159 static void br_dev_uninit(struct net_device *dev)
0160 {
0161     struct net_bridge *br = netdev_priv(dev);
0162
0163     br_multicast_dev_del(br);
0164     br_multicast_uninit_stats(br);
0165     br_vlan_flush(br);
0166     br_mdb_hash_fini(br);
0167     br_fdb_hash_fini(br);
0168     free_percpu(dev->tstats);
0169 }
0170
0171 static int br_dev_open(struct net_device *dev)
0172 {
0173     struct net_bridge *br = netdev_priv(dev);
0174
0175     netdev_update_features(dev);
0176     netif_start_queue(dev);
0177     br_stp_enable_bridge(br);
0178     br_multicast_open(br);
0179
0180     if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
0181         br_multicast_join_snoopers(br);
0182
0183     return 0;
0184 }
0185
0186 static void br_dev_set_multicast_list(struct net_device *dev)
0187 {
0188 }
0189
0190 static void br_dev_change_rx_flags(struct net_device *dev, int change)
0191 {
0192     if (change & IFF_PROMISC)
0193         br_manage_promisc(netdev_priv(dev));
0194 }
0195
0196 static int br_dev_stop(struct net_device *dev)
0197 {
0198     struct net_bridge *br = netdev_priv(dev);
0199
0200     br_stp_disable_bridge(br);
0201     br_multicast_stop(br);
0202
0203     if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
0204         br_multicast_leave_snoopers(br);
0205
0206     netif_stop_queue(dev);
0207
0208     return 0;
0209 }
0210
0211 static int br_change_mtu(struct net_device *dev, int new_mtu)
0212 {
0213     struct net_bridge *br = netdev_priv(dev);
0214
0215     dev->mtu = new_mtu;
0216
0217     /* this flag will be cleared if the MTU was automatically adjusted */
0218     br_opt_toggle(br, BROPT_MTU_SET_BY_USER, true);
0219 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
0220     /* remember the MTU in the rtable for PMTU */
0221     dst_metric_set(&br->fake_rtable.dst, RTAX_MTU, new_mtu);
0222 #endif
0223
0224     return 0;
0225 }
0226
0227 /* Allow setting mac address to any valid ethernet address. */
0228 static int br_set_mac_address(struct net_device *dev, void *p)
0229 {
0230     struct net_bridge *br = netdev_priv(dev);
0231     struct sockaddr *addr = p;
0232
0233     if (!is_valid_ether_addr(addr->sa_data))
0234         return -EADDRNOTAVAIL;
0235
0236     /* dev_set_mac_addr() can be called by a master device on bridge's
0237      * NETDEV_UNREGISTER, but since it's being destroyed do nothing
0238      */
0239     if (dev->reg_state != NETREG_REGISTERED)
0240         return -EBUSY;
0241
0242     spin_lock_bh(&br->lock);
0243     if (!ether_addr_equal(dev->dev_addr, addr->sa_data)) {
0244         /* Mac address will be changed in br_stp_change_bridge_id(). */
0245         br_stp_change_bridge_id(br, addr->sa_data);
0246     }
0247     spin_unlock_bh(&br->lock);
0248
0249     return 0;
0250 }
0251
0252 static void br_getinfo(struct net_device *dev, struct ethtool_drvinfo *info)
0253 {
0254     strlcpy(info->driver, "bridge", sizeof(info->driver));
0255     strlcpy(info->version, BR_VERSION, sizeof(info->version));
0256     strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
0257     strlcpy(info->bus_info, "N/A", sizeof(info->bus_info));
0258 }
0259
0260 static int br_get_link_ksettings(struct net_device *dev,
0261                  struct ethtool_link_ksettings *cmd)
0262 {
0263     struct net_bridge *br = netdev_priv(dev);
0264     struct net_bridge_port *p;
0265
0266     cmd->base.duplex = DUPLEX_UNKNOWN;
0267     cmd->base.port = PORT_OTHER;
0268     cmd->base.speed = SPEED_UNKNOWN;
0269
0270     list_for_each_entry(p, &br->port_list, list) {
0271         struct ethtool_link_ksettings ecmd;
0272         struct net_device *pdev = p->dev;
0273
0274         if (!netif_running(pdev) || !netif_oper_up(pdev))
0275             continue;
0276
0277         if (__ethtool_get_link_ksettings(pdev, &ecmd))
0278             continue;
0279
0280         if (ecmd.base.speed == (__u32)SPEED_UNKNOWN)
0281             continue;
0282
0283         if (cmd->base.speed == (__u32)SPEED_UNKNOWN ||
0284             cmd->base.speed < ecmd.base.speed)
0285             cmd->base.speed = ecmd.base.speed;
0286     }
0287
0288     return 0;
0289 }
0290
0291 static netdev_features_t br_fix_features(struct net_device *dev,
0292     netdev_features_t features)
0293 {
0294     struct net_bridge *br = netdev_priv(dev);
0295
0296     return br_features_recompute(br, features);
0297 }
0298
0299 #ifdef CONFIG_NET_POLL_CONTROLLER
0300 static void br_poll_controller(struct net_device *br_dev)
0301 {
0302 }
0303
0304 static void br_netpoll_cleanup(struct net_device *dev)
0305 {
0306     struct net_bridge *br = netdev_priv(dev);
0307     struct net_bridge_port *p;
0308
0309     list_for_each_entry(p, &br->port_list, list)
0310         br_netpoll_disable(p);
0311 }
0312
0313 static int __br_netpoll_enable(struct net_bridge_port *p)
0314 {
0315     struct netpoll *np;
0316     int err;
0317
0318     np = kzalloc(sizeof(*p->np), GFP_KERNEL);
0319     if (!np)
0320         return -ENOMEM;
0321
0322     err = __netpoll_setup(np, p->dev);
0323     if (err) {
0324         kfree(np);
0325         return err;
0326     }
0327
0328     p->np = np;
0329     return err;
0330 }
0331
0332 int br_netpoll_enable(struct net_bridge_port *p)
0333 {
0334     if (!p->br->dev->npinfo)
0335         return 0;
0336
0337     return __br_netpoll_enable(p);
0338 }
0339
0340 static int br_netpoll_setup(struct net_device *dev, struct netpoll_info *ni)
0341 {
0342     struct net_bridge *br = netdev_priv(dev);
0343     struct net_bridge_port *p;
0344     int err = 0;
0345
0346     list_for_each_entry(p, &br->port_list, list) {
0347         if (!p->dev)
0348             continue;
0349         err = __br_netpoll_enable(p);
0350         if (err)
0351             goto fail;
0352     }
0353
0354 out:
0355     return err;
0356
0357 fail:
0358     br_netpoll_cleanup(dev);
0359     goto out;
0360 }
0361
0362 void br_netpoll_disable(struct net_bridge_port *p)
0363 {
0364     struct netpoll *np = p->np;
0365
0366     if (!np)
0367         return;
0368
0369     p->np = NULL;
0370
0371     __netpoll_free(np);
0372 }
0373
0374 #endif
0375
0376 static int br_add_slave(struct net_device *dev, struct net_device *slave_dev,
0377             struct netlink_ext_ack *extack)
0378
0379 {
0380     struct net_bridge *br = netdev_priv(dev);
0381
0382     return br_add_if(br, slave_dev, extack);
0383 }
0384
0385 static int br_del_slave(struct net_device *dev, struct net_device *slave_dev)
0386 {
0387     struct net_bridge *br = netdev_priv(dev);
0388
0389     return br_del_if(br, slave_dev);
0390 }
0391
0392 static int br_fill_forward_path(struct net_device_path_ctx *ctx,
0393                 struct net_device_path *path)
0394 {
0395     struct net_bridge_fdb_entry *f;
0396     struct net_bridge_port *dst;
0397     struct net_bridge *br;
0398
0399     if (netif_is_bridge_port(ctx->dev))
0400         return -1;
0401
0402     br = netdev_priv(ctx->dev);
0403
0404     br_vlan_fill_forward_path_pvid(br, ctx, path);
0405
0406     f = br_fdb_find_rcu(br, ctx->daddr, path->bridge.vlan_id);
0407     if (!f || !f->dst)
0408         return -1;
0409
0410     dst = READ_ONCE(f->dst);
0411     if (!dst)
0412         return -1;
0413
0414     if (br_vlan_fill_forward_path_mode(br, dst, path))
0415         return -1;
0416
0417     path->type = DEV_PATH_BRIDGE;
0418     path->dev = dst->br->dev;
0419     ctx->dev = dst->dev;
0420
0421     switch (path->bridge.vlan_mode) {
0422     case DEV_PATH_BR_VLAN_TAG:
0423         if (ctx->num_vlans >= ARRAY_SIZE(ctx->vlan))
0424             return -ENOSPC;
0425         ctx->vlan[ctx->num_vlans].id = path->bridge.vlan_id;
0426         ctx->vlan[ctx->num_vlans].proto = path->bridge.vlan_proto;
0427         ctx->num_vlans++;
0428         break;
0429     case DEV_PATH_BR_VLAN_UNTAG_HW:
0430     case DEV_PATH_BR_VLAN_UNTAG:
0431         ctx->num_vlans--;
0432         break;
0433     case DEV_PATH_BR_VLAN_KEEP:
0434         break;
0435     }
0436
0437     return 0;
0438 }
0439
0440 static const struct ethtool_ops br_ethtool_ops = {
0441     .get_drvinfo         = br_getinfo,
0442     .get_link        = ethtool_op_get_link,
0443     .get_link_ksettings  = br_get_link_ksettings,
0444 };
0445
0446 static const struct net_device_ops br_netdev_ops = {
0447     .ndo_open        = br_dev_open,
0448     .ndo_stop        = br_dev_stop,
0449     .ndo_init        = br_dev_init,
0450     .ndo_uninit      = br_dev_uninit,
0451     .ndo_start_xmit      = br_dev_xmit,
0452     .ndo_get_stats64     = dev_get_tstats64,
0453     .ndo_set_mac_address     = br_set_mac_address,
0454     .ndo_set_rx_mode     = br_dev_set_multicast_list,
0455     .ndo_change_rx_flags     = br_dev_change_rx_flags,
0456     .ndo_change_mtu      = br_change_mtu,
0457     .ndo_siocdevprivate  = br_dev_siocdevprivate,
0458 #ifdef CONFIG_NET_POLL_CONTROLLER
0459     .ndo_netpoll_setup   = br_netpoll_setup,
0460     .ndo_netpoll_cleanup     = br_netpoll_cleanup,
0461     .ndo_poll_controller     = br_poll_controller,
0462 #endif
0463     .ndo_add_slave       = br_add_slave,
0464     .ndo_del_slave       = br_del_slave,
0465     .ndo_fix_features        = br_fix_features,
0466     .ndo_fdb_add         = br_fdb_add,
0467     .ndo_fdb_del         = br_fdb_delete,
0468     .ndo_fdb_del_bulk    = br_fdb_delete_bulk,
0469     .ndo_fdb_dump        = br_fdb_dump,
0470     .ndo_fdb_get         = br_fdb_get,
0471     .ndo_bridge_getlink  = br_getlink,
0472     .ndo_bridge_setlink  = br_setlink,
0473     .ndo_bridge_dellink  = br_dellink,
0474     .ndo_features_check  = passthru_features_check,
0475     .ndo_fill_forward_path   = br_fill_forward_path,
0476 };
0477
0478 static struct device_type br_type = {
0479     .name   = "bridge",
0480 };
0481
0482 void br_dev_setup(struct net_device *dev)
0483 {
0484     struct net_bridge *br = netdev_priv(dev);
0485
0486     eth_hw_addr_random(dev);
0487     ether_setup(dev);
0488
0489     dev->netdev_ops = &br_netdev_ops;
0490     dev->needs_free_netdev = true;
0491     dev->ethtool_ops = &br_ethtool_ops;
0492     SET_NETDEV_DEVTYPE(dev, &br_type);
0493     dev->priv_flags = IFF_EBRIDGE | IFF_NO_QUEUE;
0494
0495     dev->features = COMMON_FEATURES | NETIF_F_LLTX | NETIF_F_NETNS_LOCAL |
0496             NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
0497     dev->hw_features = COMMON_FEATURES | NETIF_F_HW_VLAN_CTAG_TX |
0498                NETIF_F_HW_VLAN_STAG_TX;
0499     dev->vlan_features = COMMON_FEATURES;
0500
0501     br->dev = dev;
0502     spin_lock_init(&br->lock);
0503     INIT_LIST_HEAD(&br->port_list);
0504     INIT_HLIST_HEAD(&br->fdb_list);
0505     INIT_HLIST_HEAD(&br->frame_type_list);
0506 #if IS_ENABLED(CONFIG_BRIDGE_MRP)
0507     INIT_HLIST_HEAD(&br->mrp_list);
0508 #endif
0509 #if IS_ENABLED(CONFIG_BRIDGE_CFM)
0510     INIT_HLIST_HEAD(&br->mep_list);
0511 #endif
0512     spin_lock_init(&br->hash_lock);
0513
0514     br->bridge_id.prio[0] = 0x80;
0515     br->bridge_id.prio[1] = 0x00;
0516
0517     ether_addr_copy(br->group_addr, eth_stp_addr);
0518
0519     br->stp_enabled = BR_NO_STP;
0520     br->group_fwd_mask = BR_GROUPFWD_DEFAULT;
0521     br->group_fwd_mask_required = BR_GROUPFWD_DEFAULT;
0522
0523     br->designated_root = br->bridge_id;
0524     br->bridge_max_age = br->max_age = 20 * HZ;
0525     br->bridge_hello_time = br->hello_time = 2 * HZ;
0526     br->bridge_forward_delay = br->forward_delay = 15 * HZ;
0527     br->bridge_ageing_time = br->ageing_time = BR_DEFAULT_AGEING_TIME;
0528     dev->max_mtu = ETH_MAX_MTU;
0529
0530     br_netfilter_rtable_init(br);
0531     br_stp_timer_init(br);
0532     br_multicast_init(br);
0533     INIT_DELAYED_WORK(&br->gc_work, br_fdb_cleanup);
0534 }