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/if_arp.h>
  18 #include <linux/if_bridge.h>
  19 #include <linux/inetdevice.h>
  20 #include <linux/module.h>
  21 #include <linux/init.h>
  22 #include <linux/rtnetlink.h>
  23 #include <net/sock.h>
  24 #include <asm/uaccess.h>
  25 #include "br_private.h"
  26
  27 static int br_initial_port_cost(struct net_device *dev)
  28 {
  29         if (!strncmp(dev->name, "lec", 3))
  30                 return 7;
  31
  32         if (!strncmp(dev->name, "eth", 3))
  33                 return 100;                     /* FIXME handle 100Mbps */
  34
  35         if (!strncmp(dev->name, "plip", 4))
  36                 return 2500;
  37
  38         return 100;
  39 }
  40
  41 static void destroy_nbp(void *arg)
  42 {
  43         struct net_bridge_port *p = arg;
  44         dev_put(p->dev);
  45         kfree(p);
  46 }
  47
  48 /* called under bridge lock */
  49 static void del_nbp(struct net_bridge_port *p)
  50 {
  51         struct net_device *dev = p->dev;
  52
  53         br_stp_disable_port(p);
  54
  55         dev_set_promiscuity(dev, -1);
  56         dev->br_port = NULL;
  57
  58         list_del_rcu(&p->list);
  59
  60         br_fdb_delete_by_port(p->br, p);
  61
  62         call_rcu(&p->rcu, destroy_nbp, p);
  63 }
  64
  65 static void del_ifs(struct net_bridge *br)
  66 {
  67         struct list_head *p, *n;
  68
  69         spin_lock_bh(&br->lock);
  70         list_for_each_safe(p, n, &br->port_list) {
  71                 del_nbp(list_entry(p, struct net_bridge_port, list));
  72         }
  73         spin_unlock_bh(&br->lock);
  74 }
  75
  76 static struct net_bridge *new_nb(const char *name)
  77 {
  78         struct net_bridge *br;
  79         struct net_device *dev;
  80
  81         dev = alloc_netdev(sizeof(struct net_bridge), name,
  82                            br_dev_setup);
  83
  84         if (!dev)
  85                 return NULL;
  86
  87         br = dev->priv;
  88         br->dev = dev;
  89
  90         br->lock = SPIN_LOCK_UNLOCKED;
  91         INIT_LIST_HEAD(&br->port_list);
  92         br->hash_lock = RW_LOCK_UNLOCKED;
  93
  94         br->bridge_id.prio[0] = 0x80;
  95         br->bridge_id.prio[1] = 0x00;
  96         memset(br->bridge_id.addr, 0, ETH_ALEN);
  97
  98         br->stp_enabled = 0;
  99         br->designated_root = br->bridge_id;
 100         br->root_path_cost = 0;
 101         br->root_port = 0;
 102         br->bridge_max_age = br->max_age = 20 * HZ;
 103         br->bridge_hello_time = br->hello_time = 2 * HZ;
 104         br->bridge_forward_delay = br->forward_delay = 15 * HZ;
 105         br->topology_change = 0;
 106         br->topology_change_detected = 0;
 107         br->ageing_time = 300 * HZ;
 108         INIT_LIST_HEAD(&br->age_list);
 109
 110         br_stp_timer_init(br);
 111
 112         return br;
 113 }
 114
 115 /* called under bridge lock */
 116 static struct net_bridge_port *new_nbp(struct net_bridge *br, struct net_device *dev)
 117 {
 118         int i;
 119         struct net_bridge_port *p;
 120
 121         p = kmalloc(sizeof(*p), GFP_ATOMIC);
 122         if (p == NULL)
 123                 return p;
 124
 125         memset(p, 0, sizeof(*p));
 126         p->br = br;
 127         p->dev = dev;
 128         p->path_cost = br_initial_port_cost(dev);
 129         p->priority = 0x80;
 130
 131         for (i=1;i<255;i++)
 132                 if (br_get_port(br, i) == NULL)
 133                         break;
 134
 135         if (i == 255) {
 136                 kfree(p);
 137                 return NULL;
 138         }
 139
 140         dev->br_port = p;
 141
 142         p->port_no = i;
 143         br_init_port(p);
 144         p->state = BR_STATE_DISABLED;
 145
 146         list_add_rcu(&p->list, &br->port_list);
 147
 148         return p;
 149 }
 150
 151 int br_add_bridge(const char *name)
 152 {
 153         struct net_bridge *br;
 154         int ret;
 155
 156         if ((br = new_nb(name)) == NULL)
 157                 return -ENOMEM;
 158
 159         ret = register_netdev(br->dev);
 160         if (ret)
 161                 kfree(br->dev);
 162         return ret;
 163 }
 164
 165 int br_del_bridge(const char *name)
 166 {
 167         struct net_device *dev;
 168         int ret = 0;
 169
 170         rtnl_lock();
 171         dev = __dev_get_by_name(name);
 172         if (dev == NULL)
 173                 ret =  -ENXIO;  /* Could not find device */
 174
 175         else if (!(dev->priv_flags & IFF_EBRIDGE)) {
 176                 /* Attempt to delete non bridge device! */
 177                 ret = -EPERM;
 178         }
 179
 180         else if (dev->flags & IFF_UP) {
 181                 /* Not shutdown yet. */
 182                 ret = -EBUSY;
 183         }
 184
 185         else {
 186                 del_ifs((struct net_bridge *) dev->priv);
 187                 unregister_netdevice(dev);
 188         }
 189
 190         rtnl_unlock();
 191         return ret;
 192 }
 193
 194 int br_add_if(struct net_bridge *br, struct net_device *dev)
 195 {
 196         struct net_bridge_port *p;
 197
 198         if (dev->br_port != NULL)
 199                 return -EBUSY;
 200
 201         if (dev->flags & IFF_LOOPBACK || dev->type != ARPHRD_ETHER)
 202                 return -EINVAL;
 203
 204         if (dev->hard_start_xmit == br_dev_xmit)
 205                 return -ELOOP;
 206
 207         dev_hold(dev);
 208         spin_lock_bh(&br->lock);
 209         if ((p = new_nbp(br, dev)) == NULL) {
 210                 spin_unlock_bh(&br->lock);
 211                 dev_put(dev);
 212                 return -EXFULL;
 213         }
 214
 215         dev_set_promiscuity(dev, 1);
 216
 217         br_stp_recalculate_bridge_id(br);
 218         br_fdb_insert(br, p, dev->dev_addr, 1);
 219         if ((br->dev->flags & IFF_UP) && (dev->flags & IFF_UP))
 220                 br_stp_enable_port(p);
 221         spin_unlock_bh(&br->lock);
 222
 223         return 0;
 224 }
 225
 226 int br_del_if(struct net_bridge *br, struct net_device *dev)
 227 {
 228         struct net_bridge_port *p;
 229         int retval = 0;
 230
 231         spin_lock_bh(&br->lock);
 232         if ((p = dev->br_port) == NULL || p->br != br)
 233                 retval = -EINVAL;
 234         else {
 235                 del_nbp(p);
 236                 br_stp_recalculate_bridge_id(br);
 237         }
 238         spin_unlock_bh(&br->lock);
 239
 240         return retval;
 241 }
 242
 243 int br_get_bridge_ifindices(int *indices, int num)
 244 {
 245         struct net_device *dev;
 246         int i = 0;
 247
 248         rtnl_shlock();
 249         for (dev = dev_base; dev && i < num; dev = dev->next) {
 250                 if (dev->priv_flags & IFF_EBRIDGE)
 251                         indices[i++] = dev->ifindex;
 252         }
 253         rtnl_shunlock();
 254
 255         return i;
 256 }
 257
 258 void br_get_port_ifindices(struct net_bridge *br, int *ifindices)
 259 {
 260         struct net_bridge_port *p;
 261
 262         rcu_read_lock();
 263         list_for_each_entry_rcu(p, &br->port_list, list) {
 264                 ifindices[p->port_no] = p->dev->ifindex;
 265         }
 266         rcu_read_unlock();
 267 }
 268
 269
 270 void __exit br_cleanup_bridges(void)
 271 {
 272         struct net_device *dev, *nxt;
 273
 274         rtnl_lock();
 275         for (dev = dev_base; dev; dev = nxt) {
 276                 nxt = dev->next;
 277                 if (dev->priv_flags & IFF_EBRIDGE) {
 278                         pr_debug("cleanup %s\n", dev->name);
 279
 280                         del_ifs((struct net_bridge *) dev->priv);
 281
 282                         unregister_netdevice(dev);
 283                 }
 284         }
 285         rtnl_unlock();
 286
 287 }