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/netpoll.h> 17#include <linux/ethtool.h> 18#include <linux/if_arp.h> 19#include <linux/module.h> 20#include <linux/init.h> 21#include <linux/rtnetlink.h> 22#include <linux/if_ether.h> 23#include <linux/slab.h> 24#include <net/sock.h> 25 26#include "br_private.h" 27 28#ifdef HNDCTF 29#include <ctf/hndctf.h> 30#endif /* HNDCTF */ 31 32/* 33 * Determine initial path cost based on speed. 34 * using recommendations from 802.1d standard 35 * 36 * Since driver might sleep need to not be holding any locks. 37 */ 38static int port_cost(struct net_device *dev) 39{ 40 if (dev->ethtool_ops && dev->ethtool_ops->get_settings) { 41 struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET, }; 42 43 if (!dev->ethtool_ops->get_settings(dev, &ecmd)) { 44 switch(ecmd.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 57 /* Old silly heuristics based on name */ 58 if (!strncmp(dev->name, "lec", 3)) 59 return 7; 60 61 if (!strncmp(dev->name, "plip", 4)) 62 return 2500; 63 64 return 100; /* assume old 10Mbps */ 65} 66 67 68/* 69 * Check for port carrier transistions. 70 * Called from work queue to allow for calling functions that 71 * might sleep (such as speed check), and to debounce. 72 */ 73void br_port_carrier_check(struct net_bridge_port *p) 74{ 75 struct net_device *dev = p->dev; 76 struct net_bridge *br = p->br; 77 78 if (netif_carrier_ok(dev)) 79 p->path_cost = port_cost(dev); 80 81 if (netif_running(br->dev)) { 82 spin_lock_bh(&br->lock); 83 if (netif_carrier_ok(dev)) { 84 if (p->state == BR_STATE_DISABLED) 85 br_stp_enable_port(p); 86 } else { 87 if (p->state != BR_STATE_DISABLED) 88 br_stp_disable_port(p); 89 } 90 spin_unlock_bh(&br->lock); 91 } 92} 93 94static void release_nbp(struct kobject *kobj) 95{ 96 struct net_bridge_port *p 97 = container_of(kobj, struct net_bridge_port, kobj); 98 kfree(p); 99} 100 101static struct kobj_type brport_ktype = { 102#ifdef CONFIG_SYSFS 103 .sysfs_ops = &brport_sysfs_ops, 104#endif 105 .release = release_nbp, 106}; 107 108static void destroy_nbp(struct net_bridge_port *p) 109{ 110 struct net_device *dev = p->dev; 111 112 p->br = NULL; 113 p->dev = NULL; 114 dev_put(dev); 115 116 kobject_put(&p->kobj); 117} 118 119static void destroy_nbp_rcu(struct rcu_head *head) 120{ 121 struct net_bridge_port *p = 122 container_of(head, struct net_bridge_port, rcu); 123 destroy_nbp(p); 124} 125 126/* Delete port(interface) from bridge is done in two steps. 127 * via RCU. First step, marks device as down. That deletes 128 * all the timers and stops new packets from flowing through. 129 * 130 * Final cleanup doesn't occur until after all CPU's finished 131 * processing packets. 132 * 133 * Protected from multiple admin operations by RTNL mutex 134 */ 135static void del_nbp(struct net_bridge_port *p) 136{ 137 struct net_bridge *br = p->br; 138 struct net_device *dev = p->dev; 139 140 sysfs_remove_link(br->ifobj, p->dev->name); 141 142 dev_set_promiscuity(dev, -1); 143 144 spin_lock_bh(&br->lock); 145 br_stp_disable_port(p); 146 spin_unlock_bh(&br->lock); 147 148 br_ifinfo_notify(RTM_DELLINK, p); 149 150 br_fdb_delete_by_port(br, p, 1); 151 152 list_del_rcu(&p->list); 153 154 dev->priv_flags &= ~IFF_BRIDGE_PORT; 155 156 netdev_rx_handler_unregister(dev); 157 158 br_multicast_del_port(p); 159 160 kobject_uevent(&p->kobj, KOBJ_REMOVE); 161 kobject_del(&p->kobj); 162 163 br_netpoll_disable(p); 164 165 call_rcu(&p->rcu, destroy_nbp_rcu); 166} 167 168/* called with RTNL */ 169static void del_br(struct net_bridge *br, struct list_head *head) 170{ 171 struct net_bridge_port *p, *n; 172 173 list_for_each_entry_safe(p, n, &br->port_list, list) { 174 del_nbp(p); 175 } 176 177 del_timer_sync(&br->gc_timer); 178 179 br_sysfs_delbr(br->dev); 180 unregister_netdevice_queue(br->dev, head); 181} 182 183static struct net_device *new_bridge_dev(struct net *net, const char *name) 184{ 185 struct net_bridge *br; 186 struct net_device *dev; 187 188 dev = alloc_netdev(sizeof(struct net_bridge), name, 189 br_dev_setup); 190 191 if (!dev) 192 return NULL; 193 dev_net_set(dev, net); 194 195 br = netdev_priv(dev); 196 br->dev = dev; 197 198 br->stats = alloc_percpu(struct br_cpu_netstats); 199 if (!br->stats) { 200 free_netdev(dev); 201 return NULL; 202 } 203 204 spin_lock_init(&br->lock); 205 INIT_LIST_HEAD(&br->port_list); 206 spin_lock_init(&br->hash_lock); 207 208 br->bridge_id.prio[0] = 0x80; 209 br->bridge_id.prio[1] = 0x00; 210 211 memcpy(br->group_addr, br_group_address, ETH_ALEN); 212 213 br->feature_mask = dev->features; 214 br->stp_enabled = BR_NO_STP; 215 br->designated_root = br->bridge_id; 216 br->root_path_cost = 0; 217 br->root_port = 0; 218 br->bridge_max_age = br->max_age = 20 * HZ; 219 br->bridge_hello_time = br->hello_time = 2 * HZ; 220 br->bridge_forward_delay = br->forward_delay = 15 * HZ; 221 br->topology_change = 0; 222 br->topology_change_detected = 0; 223 br->ageing_time = 300 * HZ; 224 225 br_netfilter_rtable_init(br); 226 227 br_stp_timer_init(br); 228 br_multicast_init(br); 229 230 return dev; 231} 232 233/* find an available port number */ 234static int find_portno(struct net_bridge *br) 235{ 236 int index; 237 struct net_bridge_port *p; 238 unsigned long *inuse; 239 240 inuse = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long), 241 GFP_KERNEL); 242 if (!inuse) 243 return -ENOMEM; 244 245 set_bit(0, inuse); /* zero is reserved */ 246 list_for_each_entry(p, &br->port_list, list) { 247 set_bit(p->port_no, inuse); 248 } 249 index = find_first_zero_bit(inuse, BR_MAX_PORTS); 250 kfree(inuse); 251 252 return (index >= BR_MAX_PORTS) ? -EXFULL : index; 253} 254 255/* called with RTNL but without bridge lock */ 256static struct net_bridge_port *new_nbp(struct net_bridge *br, 257 struct net_device *dev) 258{ 259 int index; 260 struct net_bridge_port *p; 261 262 index = find_portno(br); 263 if (index < 0) 264 return ERR_PTR(index); 265 266 p = kzalloc(sizeof(*p), GFP_KERNEL); 267 if (p == NULL) 268 return ERR_PTR(-ENOMEM); 269 270 p->br = br; 271 dev_hold(dev); 272 p->dev = dev; 273 p->path_cost = port_cost(dev); 274 p->priority = 0x8000 >> BR_PORT_BITS; 275 p->port_no = index; 276 p->flags = 0; 277 br_init_port(p); 278 p->state = BR_STATE_DISABLED; 279 br_stp_port_timer_init(p); 280 br_multicast_add_port(p); 281 282 return p; 283} 284 285static struct device_type br_type = { 286 .name = "bridge", 287}; 288 289int br_add_bridge(struct net *net, const char *name) 290{ 291 struct net_device *dev; 292 int ret; 293 294 dev = new_bridge_dev(net, name); 295 if (!dev) 296 return -ENOMEM; 297 298 rtnl_lock(); 299 if (strchr(dev->name, '%')) { 300 ret = dev_alloc_name(dev, dev->name); 301 if (ret < 0) 302 goto out_free; 303 } 304 305 SET_NETDEV_DEVTYPE(dev, &br_type); 306 307 ret = register_netdevice(dev); 308 if (ret) 309 goto out_free; 310 311#ifdef HNDCTF 312 if ((ctf_dev_register(kcih, dev, TRUE) != BCME_OK) || 313 (ctf_enable(kcih, dev, TRUE, NULL) != BCME_OK)) { 314 ctf_dev_unregister(kcih, dev); 315 unregister_netdevice(dev); 316 ret = -ENXIO; 317 goto out_free; 318 } 319#endif /* HNDCTF */ 320 321 ret = br_sysfs_addbr(dev); 322 if (ret) 323 unregister_netdevice(dev); 324 out: 325 rtnl_unlock(); 326 return ret; 327 328out_free: 329 free_netdev(dev); 330 goto out; 331} 332 333int br_del_bridge(struct net *net, const char *name) 334{ 335 struct net_device *dev; 336 int ret = 0; 337 338 rtnl_lock(); 339 dev = __dev_get_by_name(net, name); 340 if (dev == NULL) 341 ret = -ENXIO; /* Could not find device */ 342 343 else if (!(dev->priv_flags & IFF_EBRIDGE)) { 344 /* Attempt to delete non bridge device! */ 345 ret = -EPERM; 346 } 347 348 else if (dev->flags & IFF_UP) { 349 /* Not shutdown yet. */ 350 ret = -EBUSY; 351 } 352 353 else { 354#ifdef HNDCTF 355 ctf_dev_unregister(kcih, dev); 356#endif /* HNDCTF */ 357 del_br(netdev_priv(dev), NULL); 358 } 359 360 rtnl_unlock(); 361 return ret; 362} 363 364/* MTU of the bridge pseudo-device: ETH_DATA_LEN or the minimum of the ports */ 365int br_min_mtu(const struct net_bridge *br) 366{ 367 const struct net_bridge_port *p; 368 int mtu = 0; 369 370 ASSERT_RTNL(); 371 372 if (list_empty(&br->port_list)) 373 mtu = ETH_DATA_LEN; 374 else { 375 list_for_each_entry(p, &br->port_list, list) { 376 if (!mtu || p->dev->mtu < mtu) 377 mtu = p->dev->mtu; 378 } 379 } 380 return mtu; 381} 382 383/* 384 * Recomputes features using slave's features 385 */ 386void br_features_recompute(struct net_bridge *br) 387{ 388 struct net_bridge_port *p; 389 unsigned long features, mask; 390 391 features = mask = br->feature_mask; 392 if (list_empty(&br->port_list)) 393 goto done; 394 395 features &= ~NETIF_F_ONE_FOR_ALL; 396 397 list_for_each_entry(p, &br->port_list, list) { 398 features = netdev_increment_features(features, 399 p->dev->features, mask); 400 } 401 402done: 403 br->dev->features = netdev_fix_features(features, NULL); 404} 405 406/* called with RTNL */ 407int br_add_if(struct net_bridge *br, struct net_device *dev) 408{ 409 struct net_bridge_port *p; 410 int err = 0; 411 412 /* Don't allow bridging non-ethernet like devices */ 413 if ((dev->flags & IFF_LOOPBACK) || 414 dev->type != ARPHRD_ETHER || dev->addr_len != ETH_ALEN) 415 return -EINVAL; 416 417 /* No bridging of bridges */ 418 if (dev->netdev_ops->ndo_start_xmit == br_dev_xmit) 419 return -ELOOP; 420 421 /* Device is already being bridged */ 422 if (br_port_exists(dev)) 423 return -EBUSY; 424 425 /* No bridging devices that dislike that (e.g. wireless) */ 426 if (dev->priv_flags & IFF_DONT_BRIDGE) 427 return -EOPNOTSUPP; 428 429 p = new_nbp(br, dev); 430 if (IS_ERR(p)) 431 return PTR_ERR(p); 432 433 err = dev_set_promiscuity(dev, 1); 434 if (err) 435 goto put_back; 436 437 err = kobject_init_and_add(&p->kobj, &brport_ktype, &(dev->dev.kobj), 438 SYSFS_BRIDGE_PORT_ATTR); 439 if (err) 440 goto err0; 441 442 err = br_fdb_insert(br, p, dev->dev_addr); 443 if (err) 444 goto err1; 445 446 err = br_sysfs_addif(p); 447 if (err) 448 goto err2; 449 450 if (br_netpoll_info(br) && ((err = br_netpoll_enable(p)))) 451 goto err3; 452 453 err = netdev_rx_handler_register(dev, br_handle_frame, p); 454 if (err) 455 goto err3; 456 457 dev->priv_flags |= IFF_BRIDGE_PORT; 458 459 dev_disable_lro(dev); 460 461 list_add_rcu(&p->list, &br->port_list); 462 463 spin_lock_bh(&br->lock); 464 br_stp_recalculate_bridge_id(br); 465 br_features_recompute(br); 466 467 if ((dev->flags & IFF_UP) && netif_carrier_ok(dev) && 468 (br->dev->flags & IFF_UP)) 469 br_stp_enable_port(p); 470 spin_unlock_bh(&br->lock); 471 472 br_ifinfo_notify(RTM_NEWLINK, p); 473 474 dev_set_mtu(br->dev, br_min_mtu(br)); 475 476 kobject_uevent(&p->kobj, KOBJ_ADD); 477 478 return 0; 479err3: 480 sysfs_remove_link(br->ifobj, p->dev->name); 481err2: 482 br_fdb_delete_by_port(br, p, 1); 483err1: 484 kobject_put(&p->kobj); 485 p = NULL; /* kobject_put frees */ 486err0: 487 dev_set_promiscuity(dev, -1); 488put_back: 489 dev_put(dev); 490 kfree(p); 491 return err; 492} 493 494/* called with RTNL */ 495int br_del_if(struct net_bridge *br, struct net_device *dev) 496{ 497 struct net_bridge_port *p; 498 499 if (!br_port_exists(dev)) 500 return -EINVAL; 501 502 p = br_port_get(dev); 503 if (p->br != br) 504 return -EINVAL; 505 506 del_nbp(p); 507 508 spin_lock_bh(&br->lock); 509 br_stp_recalculate_bridge_id(br); 510 br_features_recompute(br); 511 spin_unlock_bh(&br->lock); 512 513 return 0; 514} 515 516void __net_exit br_net_exit(struct net *net) 517{ 518 struct net_device *dev; 519 LIST_HEAD(list); 520 521 rtnl_lock(); 522 for_each_netdev(net, dev) 523 if (dev->priv_flags & IFF_EBRIDGE) 524 del_br(netdev_priv(dev), &list); 525 526 unregister_netdevice_many(&list); 527 rtnl_unlock(); 528 529} 530