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