net/bridge/br_if.c

   1 /*
   2  *      Userspace interface
   3  *      Linux ethernet bridge
   4  *
   5  *      Authors:
   6  *      Lennert Buytenhek               <buytenh@gnu.org>
   7  *
   8  *      $Id: br_if.c,v 1.7 2001/12/24 00:59:55 davem Exp $
   9  *
  10  *      This program is free software; you can redistribute it and/or
  11  *      modify it under the terms of the GNU General Public License
  12  *      as published by the Free Software Foundation; either version
  13  *      2 of the License, or (at your option) any later version.
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/netdevice.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 <net/sock.h>
  24
  25 #include "br_private.h"
  26
  27 /*
  28  * Determine initial path cost based on speed.
  29  * using recommendations from 802.1d standard
  30  *
  31  * Need to simulate user ioctl because not all device's that support
  32  * ethtool, use ethtool_ops.  Also, since driver might sleep need to
  33  * not be holding any locks.
  34  */
  35 static int br_initial_port_cost(struct net_device *dev)
  36 {
  37
  38         struct ethtool_cmd ecmd = { ETHTOOL_GSET };
  39         struct ifreq ifr;
  40         mm_segment_t old_fs;
  41         int err;
  42
  43         strncpy(ifr.ifr_name, dev->name, IFNAMSIZ);
  44         ifr.ifr_data = (void *) &ecmd;
  45
  46         old_fs = get_fs();
  47         set_fs(KERNEL_DS);
  48         err = dev_ethtool(&ifr);
  49         set_fs(old_fs);
  50
  51         if (!err) {
  52                 switch(ecmd.speed) {
  53                 case SPEED_100:
  54                         return 19;
  55                 case SPEED_1000:
  56                         return 4;
  57                 case SPEED_10000:
  58                         return 2;
  59                 case SPEED_10:
  60                         return 100;
  61                 default:
  62                         pr_info("bridge: can't decode speed from %s: %d\n",
  63                                 dev->name, ecmd.speed);
  64                         return 100;
  65                 }
  66         }
  67
  68         /* Old silly heuristics based on name */
  69         if (!strncmp(dev->name, "lec", 3))
  70                 return 7;
  71
  72         if (!strncmp(dev->name, "plip", 4))
  73                 return 2500;
  74
  75         return 100;     /* assume old 10Mbps */
  76 }
  77
  78 static void destroy_nbp(void *arg)
  79 {
  80         struct net_bridge_port *p = arg;
  81
  82         p->dev->br_port = NULL;
  83
  84         BUG_ON(timer_pending(&p->message_age_timer));
  85         BUG_ON(timer_pending(&p->forward_delay_timer));
  86         BUG_ON(timer_pending(&p->hold_timer));
  87
  88         dev_put(p->dev);
  89         kfree(p);
  90 }
  91
  92 /* called under bridge lock */
  93 static void del_nbp(struct net_bridge_port *p)
  94 {
  95         struct net_device *dev = p->dev;
  96
  97         br_stp_disable_port(p);
  98
  99         dev_set_promiscuity(dev, -1);
 100
 101         list_del_rcu(&p->list);
 102
 103         br_fdb_delete_by_port(p->br, p);
 104
 105         del_timer(&p->message_age_timer);
 106         del_timer(&p->forward_delay_timer);
 107         del_timer(&p->hold_timer);
 108
 109         call_rcu(&p->rcu, destroy_nbp, p);
 110 }
 111
 112 static void del_br(struct net_bridge *br)
 113 {
 114         struct list_head *p, *n;
 115
 116         spin_lock_bh(&br->lock);
 117         list_for_each_safe(p, n, &br->port_list) {
 118                 del_nbp(list_entry(p, struct net_bridge_port, list));
 119         }
 120         spin_unlock_bh(&br->lock);
 121
 122         del_timer_sync(&br->gc_timer);
 123
 124         unregister_netdevice(br->dev);
 125 }
 126
 127 static struct net_bridge *new_nb(const char *name)
 128 {
 129         struct net_bridge *br;
 130         struct net_device *dev;
 131
 132         dev = alloc_netdev(sizeof(struct net_bridge), name,
 133                            br_dev_setup);
 134
 135         if (!dev)
 136                 return NULL;
 137
 138         br = dev->priv;
 139         br->dev = dev;
 140
 141         br->lock = SPIN_LOCK_UNLOCKED;
 142         INIT_LIST_HEAD(&br->port_list);
 143         br->hash_lock = RW_LOCK_UNLOCKED;
 144
 145         br->bridge_id.prio[0] = 0x80;
 146         br->bridge_id.prio[1] = 0x00;
 147         memset(br->bridge_id.addr, 0, ETH_ALEN);
 148
 149         br->stp_enabled = 0;
 150         br->designated_root = br->bridge_id;
 151         br->root_path_cost = 0;
 152         br->root_port = 0;
 153         br->bridge_max_age = br->max_age = 20 * HZ;
 154         br->bridge_hello_time = br->hello_time = 2 * HZ;
 155         br->bridge_forward_delay = br->forward_delay = 15 * HZ;
 156         br->topology_change = 0;
 157         br->topology_change_detected = 0;
 158         br->ageing_time = 300 * HZ;
 159         INIT_LIST_HEAD(&br->age_list);
 160
 161         br_stp_timer_init(br);
 162
 163         return br;
 164 }
 165
 166 /* find an available port number */
 167 static int find_portno(struct net_bridge *br)
 168 {
 169         int index;
 170         struct net_bridge_port *p;
 171         unsigned long *inuse;
 172
 173         inuse = kmalloc(BITS_TO_LONGS(BR_MAX_PORTS)*sizeof(unsigned long),
 174                         GFP_ATOMIC);
 175         if (!inuse)
 176                 return -ENOMEM;
 177
 178         memset(inuse, 0, BITS_TO_LONGS(BR_MAX_PORTS)*sizeof(unsigned long));
 179         set_bit(0, inuse);      /* zero is reserved */
 180         list_for_each_entry(p, &br->port_list, list) {
 181                 set_bit(p->port_no, inuse);
 182         }
 183         index = find_first_zero_bit(inuse, BR_MAX_PORTS);
 184         kfree(inuse);
 185
 186         return (index >= BR_MAX_PORTS) ? -EXFULL : index;
 187 }
 188
 189 /* called under bridge lock */
 190 static struct net_bridge_port *new_nbp(struct net_bridge *br,
 191                                        struct net_device *dev,
 192                                        unsigned long cost)
 193 {
 194         int index;
 195         struct net_bridge_port *p;
 196
 197         index = find_portno(br);
 198         if (index < 0)
 199                 return ERR_PTR(index);
 200
 201         p = kmalloc(sizeof(*p), GFP_ATOMIC);
 202         if (p == NULL)
 203                 return ERR_PTR(-ENOMEM);
 204
 205         memset(p, 0, sizeof(*p));
 206         p->br = br;
 207         dev_hold(dev);
 208         p->dev = dev;
 209         p->path_cost = cost;
 210         p->priority = 0x8000 >> BR_PORT_BITS;
 211         dev->br_port = p;
 212         p->port_no = index;
 213         br_init_port(p);
 214         p->state = BR_STATE_DISABLED;
 215
 216         return p;
 217 }
 218
 219 int br_add_bridge(const char *name)
 220 {
 221         struct net_bridge *br;
 222         int ret;
 223
 224         if ((br = new_nb(name)) == NULL)
 225                 return -ENOMEM;
 226
 227         ret = register_netdev(br->dev);
 228         if (ret)
 229                 free_netdev(br->dev);
 230         return ret;
 231 }
 232
 233 int br_del_bridge(const char *name)
 234 {
 235         struct net_device *dev;
 236         int ret = 0;
 237
 238         rtnl_lock();
 239         dev = __dev_get_by_name(name);
 240         if (dev == NULL)
 241                 ret =  -ENXIO;  /* Could not find device */
 242
 243         else if (!(dev->priv_flags & IFF_EBRIDGE)) {
 244                 /* Attempt to delete non bridge device! */
 245                 ret = -EPERM;
 246         }
 247
 248         else if (dev->flags & IFF_UP) {
 249                 /* Not shutdown yet. */
 250                 ret = -EBUSY;
 251         }
 252
 253         else
 254                 del_br(dev->priv);
 255
 256         rtnl_unlock();
 257         return ret;
 258 }
 259
 260 int br_add_if(struct net_bridge *br, struct net_device *dev)
 261 {
 262         struct net_bridge_port *p;
 263         unsigned long cost;
 264         int err = 0;
 265
 266         if (dev->flags & IFF_LOOPBACK || dev->type != ARPHRD_ETHER)
 267                 return -EINVAL;
 268
 269         if (dev->hard_start_xmit == br_dev_xmit)
 270                 return -ELOOP;
 271
 272         cost = br_initial_port_cost(dev);
 273
 274         spin_lock_bh(&br->lock);
 275         if (dev->br_port != NULL)
 276                 err = -EBUSY;
 277
 278         else if (IS_ERR(p = new_nbp(br, dev, cost)))
 279                 err = PTR_ERR(p);
 280
 281         else if ((err = br_fdb_insert(br, p, dev->dev_addr, 1)))
 282                  destroy_nbp(p);
 283
 284         else {
 285                 dev_set_promiscuity(dev, 1);
 286
 287                 list_add_rcu(&p->list, &br->port_list);
 288
 289                 br_stp_recalculate_bridge_id(br);
 290                 if ((br->dev->flags & IFF_UP) && (dev->flags & IFF_UP))
 291                         br_stp_enable_port(p);
 292
 293         }
 294         spin_unlock_bh(&br->lock);
 295         return err;
 296 }
 297
 298 int br_del_if(struct net_bridge *br, struct net_device *dev)
 299 {
 300         struct net_bridge_port *p;
 301         int err = 0;
 302
 303         spin_lock_bh(&br->lock);
 304         p = dev->br_port;
 305         if (!p || p->br != br)
 306                 err = -EINVAL;
 307         else {
 308                 del_nbp(p);
 309                 br_stp_recalculate_bridge_id(br);
 310         }
 311         spin_unlock_bh(&br->lock);
 312
 313         return err;
 314 }
 315
 316 int br_get_bridge_ifindices(int *indices, int num)
 317 {
 318         struct net_device *dev;
 319         int i = 0;
 320
 321         read_lock(&dev_base_lock);
 322         for (dev = dev_base; dev && i < num; dev = dev->next) {
 323                 if (dev->priv_flags & IFF_EBRIDGE)
 324                         indices[i++] = dev->ifindex;
 325         }
 326         read_unlock(&dev_base_lock);
 327
 328         return i;
 329 }
 330
 331 void br_get_port_ifindices(struct net_bridge *br, int *ifindices, int num)
 332 {
 333         struct net_bridge_port *p;
 334
 335         rcu_read_lock();
 336         list_for_each_entry_rcu(p, &br->port_list, list) {
 337                 if (p->port_no < num)
 338                         ifindices[p->port_no] = p->dev->ifindex;
 339         }
 340         rcu_read_unlock();
 341 }
 342
 343
 344 void __exit br_cleanup_bridges(void)
 345 {
 346         struct net_device *dev, *nxt;
 347
 348         rtnl_lock();
 349         for (dev = dev_base; dev; dev = nxt) {
 350                 nxt = dev->next;
 351                 if (dev->priv_flags & IFF_EBRIDGE)
 352                         del_br(dev->priv);
 353         }
 354         rtnl_unlock();
 355
 356 }