linux/net/bridge/br_if.c
<<
>>
Prefs
   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/sock.h>
  26
  27#include "br_private.h"
  28
  29/*
  30 * Determine initial path cost based on speed.
  31 * using recommendations from 802.1d standard
  32 *
  33 * Since driver might sleep need to not be holding any locks.
  34 */
  35static int port_cost(struct net_device *dev)
  36{
  37        struct ethtool_cmd ecmd;
  38
  39        if (!__ethtool_get_settings(dev, &ecmd)) {
  40                switch (ethtool_cmd_speed(&ecmd)) {
  41                case SPEED_10000:
  42                        return 2;
  43                case SPEED_1000:
  44                        return 4;
  45                case SPEED_100:
  46                        return 19;
  47                case SPEED_10:
  48                        return 100;
  49                }
  50        }
  51
  52        /* Old silly heuristics based on name */
  53        if (!strncmp(dev->name, "lec", 3))
  54                return 7;
  55
  56        if (!strncmp(dev->name, "plip", 4))
  57                return 2500;
  58
  59        return 100;     /* assume old 10Mbps */
  60}
  61
  62
  63/* Check for port carrier transistions. */
  64void br_port_carrier_check(struct net_bridge_port *p)
  65{
  66        struct net_device *dev = p->dev;
  67        struct net_bridge *br = p->br;
  68
  69        if (netif_running(dev) && netif_carrier_ok(dev))
  70                p->path_cost = port_cost(dev);
  71
  72        if (!netif_running(br->dev))
  73                return;
  74
  75        spin_lock_bh(&br->lock);
  76        if (netif_running(dev) && netif_carrier_ok(dev)) {
  77                if (p->state == BR_STATE_DISABLED)
  78                        br_stp_enable_port(p);
  79        } else {
  80                if (p->state != BR_STATE_DISABLED)
  81                        br_stp_disable_port(p);
  82        }
  83        spin_unlock_bh(&br->lock);
  84}
  85
  86static void release_nbp(struct kobject *kobj)
  87{
  88        struct net_bridge_port *p
  89                = container_of(kobj, struct net_bridge_port, kobj);
  90        kfree(p);
  91}
  92
  93static struct kobj_type brport_ktype = {
  94#ifdef CONFIG_SYSFS
  95        .sysfs_ops = &brport_sysfs_ops,
  96#endif
  97        .release = release_nbp,
  98};
  99
 100static void destroy_nbp(struct net_bridge_port *p)
 101{
 102        struct net_device *dev = p->dev;
 103
 104        p->br = NULL;
 105        p->dev = NULL;
 106        dev_put(dev);
 107
 108        kobject_put(&p->kobj);
 109}
 110
 111static void destroy_nbp_rcu(struct rcu_head *head)
 112{
 113        struct net_bridge_port *p =
 114                        container_of(head, struct net_bridge_port, rcu);
 115        destroy_nbp(p);
 116}
 117
 118/* Delete port(interface) from bridge is done in two steps.
 119 * via RCU. First step, marks device as down. That deletes
 120 * all the timers and stops new packets from flowing through.
 121 *
 122 * Final cleanup doesn't occur until after all CPU's finished
 123 * processing packets.
 124 *
 125 * Protected from multiple admin operations by RTNL mutex
 126 */
 127static void del_nbp(struct net_bridge_port *p)
 128{
 129        struct net_bridge *br = p->br;
 130        struct net_device *dev = p->dev;
 131
 132        sysfs_remove_link(br->ifobj, p->dev->name);
 133
 134        dev_set_promiscuity(dev, -1);
 135
 136        spin_lock_bh(&br->lock);
 137        br_stp_disable_port(p);
 138        spin_unlock_bh(&br->lock);
 139
 140        br_ifinfo_notify(RTM_DELLINK, p);
 141
 142        br_fdb_delete_by_port(br, p, 1);
 143
 144        list_del_rcu(&p->list);
 145
 146        dev->priv_flags &= ~IFF_BRIDGE_PORT;
 147
 148        netdev_rx_handler_unregister(dev);
 149        synchronize_net();
 150
 151        netdev_set_master(dev, NULL);
 152
 153        br_multicast_del_port(p);
 154
 155        kobject_uevent(&p->kobj, KOBJ_REMOVE);
 156        kobject_del(&p->kobj);
 157
 158        br_netpoll_disable(p);
 159
 160        call_rcu(&p->rcu, destroy_nbp_rcu);
 161}
 162
 163/* Delete bridge device */
 164void br_dev_delete(struct net_device *dev, struct list_head *head)
 165{
 166        struct net_bridge *br = netdev_priv(dev);
 167        struct net_bridge_port *p, *n;
 168
 169        list_for_each_entry_safe(p, n, &br->port_list, list) {
 170                del_nbp(p);
 171        }
 172
 173        del_timer_sync(&br->gc_timer);
 174
 175        br_sysfs_delbr(br->dev);
 176        unregister_netdevice_queue(br->dev, head);
 177}
 178
 179/* find an available port number */
 180static int find_portno(struct net_bridge *br)
 181{
 182        int index;
 183        struct net_bridge_port *p;
 184        unsigned long *inuse;
 185
 186        inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
 187                        GFP_KERNEL);
 188        if (!inuse)
 189                return -ENOMEM;
 190
 191        set_bit(0, inuse);      /* zero is reserved */
 192        list_for_each_entry(p, &br->port_list, list) {
 193                set_bit(p->port_no, inuse);
 194        }
 195        index = find_first_zero_bit(inuse, BR_MAX_PORTS);
 196        kfree(inuse);
 197
 198        return (index >= BR_MAX_PORTS) ? -EXFULL : index;
 199}
 200
 201/* called with RTNL but without bridge lock */
 202static struct net_bridge_port *new_nbp(struct net_bridge *br,
 203                                       struct net_device *dev)
 204{
 205        int index;
 206        struct net_bridge_port *p;
 207
 208        index = find_portno(br);
 209        if (index < 0)
 210                return ERR_PTR(index);
 211
 212        p = kzalloc(sizeof(*p), GFP_KERNEL);
 213        if (p == NULL)
 214                return ERR_PTR(-ENOMEM);
 215
 216        p->br = br;
 217        dev_hold(dev);
 218        p->dev = dev;
 219        p->path_cost = port_cost(dev);
 220        p->priority = 0x8000 >> BR_PORT_BITS;
 221        p->port_no = index;
 222        p->flags = 0;
 223        br_init_port(p);
 224        p->state = BR_STATE_DISABLED;
 225        br_stp_port_timer_init(p);
 226        br_multicast_add_port(p);
 227
 228        return p;
 229}
 230
 231int br_add_bridge(struct net *net, const char *name)
 232{
 233        struct net_device *dev;
 234        int res;
 235
 236        dev = alloc_netdev(sizeof(struct net_bridge), name,
 237                           br_dev_setup);
 238
 239        if (!dev)
 240                return -ENOMEM;
 241
 242        dev_net_set(dev, net);
 243        dev->rtnl_link_ops = &br_link_ops;
 244
 245        res = register_netdev(dev);
 246        if (res)
 247                free_netdev(dev);
 248        return res;
 249}
 250
 251int br_del_bridge(struct net *net, const char *name)
 252{
 253        struct net_device *dev;
 254        int ret = 0;
 255
 256        rtnl_lock();
 257        dev = __dev_get_by_name(net, name);
 258        if (dev == NULL)
 259                ret =  -ENXIO;  /* Could not find device */
 260
 261        else if (!(dev->priv_flags & IFF_EBRIDGE)) {
 262                /* Attempt to delete non bridge device! */
 263                ret = -EPERM;
 264        }
 265
 266        else if (dev->flags & IFF_UP) {
 267                /* Not shutdown yet. */
 268                ret = -EBUSY;
 269        }
 270
 271        else
 272                br_dev_delete(dev, NULL);
 273
 274        rtnl_unlock();
 275        return ret;
 276}
 277
 278/* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */
 279int br_min_mtu(const struct net_bridge *br)
 280{
 281        const struct net_bridge_port *p;
 282        int mtu = 0;
 283
 284        ASSERT_RTNL();
 285
 286        if (list_empty(&br->port_list))
 287                mtu = ETH_DATA_LEN;
 288        else {
 289                list_for_each_entry(p, &br->port_list, list) {
 290                        if (!mtu  || p->dev->mtu < mtu)
 291                                mtu = p->dev->mtu;
 292                }
 293        }
 294        return mtu;
 295}
 296
 297/*
 298 * Recomputes features using slave's features
 299 */
 300netdev_features_t br_features_recompute(struct net_bridge *br,
 301        netdev_features_t features)
 302{
 303        struct net_bridge_port *p;
 304        netdev_features_t mask;
 305
 306        if (list_empty(&br->port_list))
 307                return features;
 308
 309        mask = features;
 310        features &= ~NETIF_F_ONE_FOR_ALL;
 311
 312        list_for_each_entry(p, &br->port_list, list) {
 313                features = netdev_increment_features(features,
 314                                                     p->dev->features, mask);
 315        }
 316
 317        return features;
 318}
 319
 320/* called with RTNL */
 321int br_add_if(struct net_bridge *br, struct net_device *dev)
 322{
 323        struct net_bridge_port *p;
 324        int err = 0;
 325        bool changed_addr;
 326
 327        /* Don't allow bridging non-ethernet like devices */
 328        if ((dev->flags & IFF_LOOPBACK) ||
 329            dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN ||
 330            !is_valid_ether_addr(dev->dev_addr))
 331                return -EINVAL;
 332
 333        /* No bridging of bridges */
 334        if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit)
 335                return -ELOOP;
 336
 337        /* Device is already being bridged */
 338        if (br_port_exists(dev))
 339                return -EBUSY;
 340
 341        /* No bridging devices that dislike that (e.g. wireless) */
 342        if (dev->priv_flags & IFF_DONT_BRIDGE)
 343                return -EOPNOTSUPP;
 344
 345        p = new_nbp(br, dev);
 346        if (IS_ERR(p))
 347                return PTR_ERR(p);
 348
 349        call_netdevice_notifiers(NETDEV_JOIN, dev);
 350
 351        err = dev_set_promiscuity(dev, 1);
 352        if (err)
 353                goto put_back;
 354
 355        err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj),
 356                                   SYSFS_BRIDGE_PORT_ATTR);
 357        if (err)
 358                goto err1;
 359
 360        err = br_sysfs_addif(p);
 361        if (err)
 362                goto err2;
 363
 364        if (br_netpoll_info(br) && ((err = br_netpoll_enable(p, GFP_KERNEL))))
 365                goto err3;
 366
 367        err = netdev_set_master(dev, br->dev);
 368        if (err)
 369                goto err3;
 370
 371        err = netdev_rx_handler_register(dev, br_handle_frame, p);
 372        if (err)
 373                goto err4;
 374
 375        dev->priv_flags |= IFF_BRIDGE_PORT;
 376
 377        dev_disable_lro(dev);
 378
 379        list_add_rcu(&p->list, &br->port_list);
 380
 381        netdev_update_features(br->dev);
 382
 383        spin_lock_bh(&br->lock);
 384        changed_addr = br_stp_recalculate_bridge_id(br);
 385
 386        if ((dev->flags & IFF_UP) && netif_carrier_ok(dev) &&
 387            (br->dev->flags & IFF_UP))
 388                br_stp_enable_port(p);
 389        spin_unlock_bh(&br->lock);
 390
 391        br_ifinfo_notify(RTM_NEWLINK, p);
 392
 393        if (changed_addr)
 394                call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
 395
 396        dev_set_mtu(br->dev, br_min_mtu(br));
 397
 398        if (br_fdb_insert(br, p, dev->dev_addr))
 399                netdev_err(dev, "failed insert local address bridge forwarding table\n");
 400
 401        kobject_uevent(&p->kobj, KOBJ_ADD);
 402
 403        return 0;
 404
 405err4:
 406        netdev_set_master(dev, NULL);
 407err3:
 408        sysfs_remove_link(br->ifobj, p->dev->name);
 409err2:
 410        kobject_put(&p->kobj);
 411        p = NULL; /* kobject_put frees */
 412err1:
 413        dev_set_promiscuity(dev, -1);
 414put_back:
 415        dev_put(dev);
 416        kfree(p);
 417        return err;
 418}
 419
 420/* called with RTNL */
 421int br_del_if(struct net_bridge *br, struct net_device *dev)
 422{
 423        struct net_bridge_port *p;
 424        bool changed_addr;
 425
 426        p = br_port_get_rtnl(dev);
 427        if (!p || p->br != br)
 428                return -EINVAL;
 429
 430        /* Since more than one interface can be attached to a bridge,
 431         * there still maybe an alternate path for netconsole to use;
 432         * therefore there is no reason for a NETDEV_RELEASE event.
 433         */
 434        del_nbp(p);
 435
 436        spin_lock_bh(&br->lock);
 437        changed_addr = br_stp_recalculate_bridge_id(br);
 438        spin_unlock_bh(&br->lock);
 439
 440        if (changed_addr)
 441                call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
 442
 443        netdev_update_features(br->dev);
 444
 445        return 0;
 446}
 447
 448void __net_exit br_net_exit(struct net *net)
 449{
 450        struct net_device *dev;
 451        LIST_HEAD(list);
 452
 453        rtnl_lock();
 454        for_each_netdev(net, dev)
 455                if (dev->priv_flags & IFF_EBRIDGE)
 456                        br_dev_delete(dev, &list);
 457
 458        unregister_netdevice_many(&list);
 459        rtnl_unlock();
 460
 461}
 462
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.