1 /* 2 * originally based on the dummy device. 3 * 4 * Copyright 1999, Thomas Davis, tadavis@lbl.gov. 5 * Licensed under the GPL. Based on dummy.c, and eql.c devices. 6 * 7 * bonding.c: an Ethernet Bonding driver 8 * 9 * This is useful to talk to a Cisco EtherChannel compatible equipment: 10 * Cisco 5500 11 * Sun Trunking (Solaris) 12 * Alteon AceDirector Trunks 13 * Linux Bonding 14 * and probably many L2 switches ... 15 * 16 * How it works: 17 * ifconfig bond0 ipaddress netmask up 18 * will setup a network device, with an ip address. No mac address 19 * will be assigned at this time. The hw mac address will come from 20 * the first slave bonded to the channel. All slaves will then use 21 * this hw mac address. 22 * 23 * ifconfig bond0 down 24 * will release all slaves, marking them as down. 25 * 26 * ifenslave bond0 eth0 27 * will attach eth0 to bond0 as a slave. eth0 hw mac address will either 28 * a: be used as initial mac address 29 * b: if a hw mac address already is there, eth0's hw mac address 30 * will then be set from bond0. 31 * 32 */ 33 34 //#define BONDING_DEBUG 1 35 36 #include <linux/kernel.h> 37 #include <linux/module.h> 38 #include <linux/types.h> 39 #include <linux/fcntl.h> 40 #include <linux/interrupt.h> 41 #include <linux/ptrace.h> 42 #include <linux/ioport.h> 43 #include <linux/in.h> 44 #include <net/ip.h> 45 #include <linux/ip.h> 46 #include <linux/tcp.h> 47 #include <linux/udp.h> 48 #include <linux/slab.h> 49 #include <linux/string.h> 50 #include <linux/init.h> 51 #include <linux/timer.h> 52 #include <linux/socket.h> 53 #include <linux/ctype.h> 54 #include <linux/inet.h> 55 #include <linux/bitops.h> 56 #include <asm/system.h> 57 #include <asm/io.h> 58 #include <asm/dma.h> 59 #include <asm/uaccess.h> 60 #include <linux/errno.h> 61 #include <linux/netdevice.h> 62 #include <linux/inetdevice.h> 63 #include <linux/igmp.h> 64 #include <linux/etherdevice.h> 65 #include <linux/skbuff.h> 66 #include <net/sock.h> 67 #include <linux/rtnetlink.h> 68 #include <linux/proc_fs.h> 69 #include <linux/seq_file.h> 70 #include <linux/smp.h> 71 #include <linux/if_ether.h> 72 #include <net/arp.h> 73 #include <linux/mii.h> 74 #include <linux/ethtool.h> 75 #include <linux/if_vlan.h> 76 #include <linux/if_bonding.h> 77 #include <linux/jiffies.h> 78 #include <net/route.h> 79 #include <net/net_namespace.h> 80 #include "bonding.h" 81 #include "bond_3ad.h" 82 #include "bond_alb.h" 83 84 /*---------------------------- Module parameters ----------------------------*/ 85 86 /* monitor all links that often (in milliseconds). <=0 disables monitoring */ 87 #define BOND_LINK_MON_INTERV 0 88 #define BOND_LINK_ARP_INTERV 0 89 90 static int max_bonds = BOND_DEFAULT_MAX_BONDS; 91 static int num_grat_arp = 1; 92 static int miimon = BOND_LINK_MON_INTERV; 93 static int updelay = 0; 94 static int downdelay = 0; 95 static int use_carrier = 1; 96 static char *mode = NULL; 97 static char *primary = NULL; 98 static char *lacp_rate = NULL; 99 static char *xmit_hash_policy = NULL; 100 static int arp_interval = BOND_LINK_ARP_INTERV; 101 static char *arp_ip_target[BOND_MAX_ARP_TARGETS] = { NULL, }; 102 static char *arp_validate = NULL; 103 static char *fail_over_mac = NULL; 104 struct bond_params bonding_defaults; 105 106 module_param(max_bonds, int, 0); 107 MODULE_PARM_DESC(max_bonds, "Max number of bonded devices"); 108 module_param(num_grat_arp, int, 0644); 109 MODULE_PARM_DESC(num_grat_arp, "Number of gratuitous ARP packets to send on failover event"); 110 module_param(miimon, int, 0); 111 MODULE_PARM_DESC(miimon, "Link check interval in milliseconds"); 112 module_param(updelay, int, 0); 113 MODULE_PARM_DESC(updelay, "Delay before considering link up, in milliseconds"); 114 module_param(downdelay, int, 0); 115 MODULE_PARM_DESC(downdelay, "Delay before considering link down, " 116 "in milliseconds"); 117 module_param(use_carrier, int, 0); 118 MODULE_PARM_DESC(use_carrier, "Use netif_carrier_ok (vs MII ioctls) in miimon; " 119 "0 for off, 1 for on (default)"); 120 module_param(mode, charp, 0); 121 MODULE_PARM_DESC(mode, "Mode of operation : 0 for balance-rr, " 122 "1 for active-backup, 2 for balance-xor, " 123 "3 for broadcast, 4 for 802.3ad, 5 for balance-tlb, " 124 "6 for balance-alb"); 125 module_param(primary, charp, 0); 126 MODULE_PARM_DESC(primary, "Primary network device to use"); 127 module_param(lacp_rate, charp, 0); 128 MODULE_PARM_DESC(lacp_rate, "LACPDU tx rate to request from 802.3ad partner " 129 "(slow/fast)"); 130 module_param(xmit_hash_policy, charp, 0); 131 MODULE_PARM_DESC(xmit_hash_policy, "XOR hashing method: 0 for layer 2 (default)" 132 ", 1 for layer 3+4"); 133 module_param(arp_interval, int, 0); 134 MODULE_PARM_DESC(arp_interval, "arp interval in milliseconds"); 135 module_param_array(arp_ip_target, charp, NULL, 0); 136 MODULE_PARM_DESC(arp_ip_target, "arp targets in n.n.n.n form"); 137 module_param(arp_validate, charp, 0); 138 MODULE_PARM_DESC(arp_validate, "validate src/dst of ARP probes: none (default), active, backup or all"); 139 module_param(fail_over_mac, charp, 0); 140 MODULE_PARM_DESC(fail_over_mac, "For active-backup, do not set all slaves to the same MAC. none (default), active or follow"); 141 142 /*----------------------------- Global variables ----------------------------*/ 143 144 static const char * const version = 145 DRV_DESCRIPTION ": v" DRV_VERSION " (" DRV_RELDATE ")\n"; 146 147 LIST_HEAD(bond_dev_list); 148 149 #ifdef CONFIG_PROC_FS 150 static struct proc_dir_entry *bond_proc_dir = NULL; 151 #endif 152 153 extern struct rw_semaphore bonding_rwsem; 154 static __be32 arp_target[BOND_MAX_ARP_TARGETS] = { 0, } ; 155 static int arp_ip_count = 0; 156 static int bond_mode = BOND_MODE_ROUNDROBIN; 157 static int xmit_hashtype= BOND_XMIT_POLICY_LAYER2; 158 static int lacp_fast = 0; 159 160 161 struct bond_parm_tbl bond_lacp_tbl[] = { 162 { "slow", AD_LACP_SLOW}, 163 { "fast", AD_LACP_FAST}, 164 { NULL, -1}, 165 }; 166 167 struct bond_parm_tbl bond_mode_tbl[] = { 168 { "balance-rr", BOND_MODE_ROUNDROBIN}, 169 { "active-backup", BOND_MODE_ACTIVEBACKUP}, 170 { "balance-xor", BOND_MODE_XOR}, 171 { "broadcast", BOND_MODE_BROADCAST}, 172 { "802.3ad", BOND_MODE_8023AD}, 173 { "balance-tlb", BOND_MODE_TLB}, 174 { "balance-alb", BOND_MODE_ALB}, 175 { NULL, -1}, 176 }; 177 178 struct bond_parm_tbl xmit_hashtype_tbl[] = { 179 { "layer2", BOND_XMIT_POLICY_LAYER2}, 180 { "layer3+4", BOND_XMIT_POLICY_LAYER34}, 181 { "layer2+3", BOND_XMIT_POLICY_LAYER23}, 182 { NULL, -1}, 183 }; 184 185 struct bond_parm_tbl arp_validate_tbl[] = { 186 { "none", BOND_ARP_VALIDATE_NONE}, 187 { "active", BOND_ARP_VALIDATE_ACTIVE}, 188 { "backup", BOND_ARP_VALIDATE_BACKUP}, 189 { "all", BOND_ARP_VALIDATE_ALL}, 190 { NULL, -1}, 191 }; 192 193 struct bond_parm_tbl fail_over_mac_tbl[] = { 194 { "none", BOND_FOM_NONE}, 195 { "active", BOND_FOM_ACTIVE}, 196 { "follow", BOND_FOM_FOLLOW}, 197 { NULL, -1}, 198 }; 199 200 /*-------------------------- Forward declarations ---------------------------*/ 201 202 static void bond_send_gratuitous_arp(struct bonding *bond); 203 static void bond_deinit(struct net_device *bond_dev); 204 205 /*---------------------------- General routines -----------------------------*/ 206 207 static const char *bond_mode_name(int mode) 208 { 209 switch (mode) { 210 case BOND_MODE_ROUNDROBIN : 211 return "load balancing (round-robin)"; 212 case BOND_MODE_ACTIVEBACKUP : 213 return "fault-tolerance (active-backup)"; 214 case BOND_MODE_XOR : 215 return "load balancing (xor)"; 216 case BOND_MODE_BROADCAST : 217 return "fault-tolerance (broadcast)"; 218 case BOND_MODE_8023AD: 219 return "IEEE 802.3ad Dynamic link aggregation"; 220 case BOND_MODE_TLB: 221 return "transmit load balancing"; 222 case BOND_MODE_ALB: 223 return "adaptive load balancing"; 224 default: 225 return "unknown"; 226 } 227 } 228 229 /*---------------------------------- VLAN -----------------------------------*/ 230 231 /** 232 * bond_add_vlan - add a new vlan id on bond 233 * @bond: bond that got the notification 234 * @vlan_id: the vlan id to add 235 * 236 * Returns -ENOMEM if allocation failed. 237 */ 238 static int bond_add_vlan(struct bonding *bond, unsigned short vlan_id) 239 { 240 struct vlan_entry *vlan; 241 242 dprintk("bond: %s, vlan id %d\n", 243 (bond ? bond->dev->name: "None"), vlan_id); 244 245 vlan = kmalloc(sizeof(struct vlan_entry), GFP_KERNEL); 246 if (!vlan) { 247 return -ENOMEM; 248 } 249 250 INIT_LIST_HEAD(&vlan->vlan_list); 251 vlan->vlan_id = vlan_id; 252 vlan->vlan_ip = 0; 253 254 write_lock_bh(&bond->lock); 255 256 list_add_tail(&vlan->vlan_list, &bond->vlan_list); 257 258 write_unlock_bh(&bond->lock); 259 260 dprintk("added VLAN ID %d on bond %s\n", vlan_id, bond->dev->name); 261 262 return 0; 263 } 264 265 /** 266 * bond_del_vlan - delete a vlan id from bond 267 * @bond: bond that got the notification 268 * @vlan_id: the vlan id to delete 269 * 270 * returns -ENODEV if @vlan_id was not found in @bond. 271 */ 272 static int bond_del_vlan(struct bonding *bond, unsigned short vlan_id) 273 { 274 struct vlan_entry *vlan; 275 int res = -ENODEV; 276 277 dprintk("bond: %s, vlan id %d\n", bond->dev->name, vlan_id); 278 279 write_lock_bh(&bond->lock); 280 281 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) { 282 if (vlan->vlan_id == vlan_id) { 283 list_del(&vlan->vlan_list); 284 285 if ((bond->params.mode == BOND_MODE_TLB) || 286 (bond->params.mode == BOND_MODE_ALB)) { 287 bond_alb_clear_vlan(bond, vlan_id); 288 } 289 290 dprintk("removed VLAN ID %d from bond %s\n", vlan_id, 291 bond->dev->name); 292 293 kfree(vlan); 294 295 if (list_empty(&bond->vlan_list) && 296 (bond->slave_cnt == 0)) { 297 /* Last VLAN removed and no slaves, so 298 * restore block on adding VLANs. This will 299 * be removed once new slaves that are not 300 * VLAN challenged will be added. 301 */ 302 bond->dev->features |= NETIF_F_VLAN_CHALLENGED; 303 } 304 305 res = 0; 306 goto out; 307 } 308 } 309 310 dprintk("couldn't find VLAN ID %d in bond %s\n", vlan_id, 311 bond->dev->name); 312 313 out: 314 write_unlock_bh(&bond->lock); 315 return res; 316 } 317 318 /** 319 * bond_has_challenged_slaves 320 * @bond: the bond we're working on 321 * 322 * Searches the slave list. Returns 1 if a vlan challenged slave 323 * was found, 0 otherwise. 324 * 325 * Assumes bond->lock is held. 326 */ 327 static int bond_has_challenged_slaves(struct bonding *bond) 328 { 329 struct slave *slave; 330 int i; 331 332 bond_for_each_slave(bond, slave, i) { 333 if (slave->dev->features & NETIF_F_VLAN_CHALLENGED) { 334 dprintk("found VLAN challenged slave - %s\n", 335 slave->dev->name); 336 return 1; 337 } 338 } 339 340 dprintk("no VLAN challenged slaves found\n"); 341 return 0; 342 } 343 344 /** 345 * bond_next_vlan - safely skip to the next item in the vlans list. 346 * @bond: the bond we're working on 347 * @curr: item we're advancing from 348 * 349 * Returns %NULL if list is empty, bond->next_vlan if @curr is %NULL, 350 * or @curr->next otherwise (even if it is @curr itself again). 351 * 352 * Caller must hold bond->lock 353 */ 354 struct vlan_entry *bond_next_vlan(struct bonding *bond, struct vlan_entry *curr) 355 { 356 struct vlan_entry *next, *last; 357 358 if (list_empty(&bond->vlan_list)) { 359 return NULL; 360 } 361 362 if (!curr) { 363 next = list_entry(bond->vlan_list.next, 364 struct vlan_entry, vlan_list); 365 } else { 366 last = list_entry(bond->vlan_list.prev, 367 struct vlan_entry, vlan_list); 368 if (last == curr) { 369 next = list_entry(bond->vlan_list.next, 370 struct vlan_entry, vlan_list); 371 } else { 372 next = list_entry(curr->vlan_list.next, 373 struct vlan_entry, vlan_list); 374 } 375 } 376 377 return next; 378 } 379 380 /** 381 * bond_dev_queue_xmit - Prepare skb for xmit. 382 * 383 * @bond: bond device that got this skb for tx. 384 * @skb: hw accel VLAN tagged skb to transmit 385 * @slave_dev: slave that is supposed to xmit this skbuff 386 * 387 * When the bond gets an skb to transmit that is 388 * already hardware accelerated VLAN tagged, and it 389 * needs to relay this skb to a slave that is not 390 * hw accel capable, the skb needs to be "unaccelerated", 391 * i.e. strip the hwaccel tag and re-insert it as part 392 * of the payload. 393 */ 394 int bond_dev_queue_xmit(struct bonding *bond, struct sk_buff *skb, struct net_device *slave_dev) 395 { 396 unsigned short uninitialized_var(vlan_id); 397 398 if (!list_empty(&bond->vlan_list) && 399 !(slave_dev->features & NETIF_F_HW_VLAN_TX) && 400 vlan_get_tag(skb, &vlan_id) == 0) { 401 skb->dev = slave_dev; 402 skb = vlan_put_tag(skb, vlan_id); 403 if (!skb) { 404 /* vlan_put_tag() frees the skb in case of error, 405 * so return success here so the calling functions 406 * won't attempt to free is again. 407 */ 408 return 0; 409 } 410 } else { 411 skb->dev = slave_dev; 412 } 413 414 skb->priority = 1; 415 dev_queue_xmit(skb); 416 417 return 0; 418 } 419 420 /* 421 * In the following 3 functions, bond_vlan_rx_register(), bond_vlan_rx_add_vid 422 * and bond_vlan_rx_kill_vid, We don't protect the slave list iteration with a 423 * lock because: 424 * a. This operation is performed in IOCTL context, 425 * b. The operation is protected by the RTNL semaphore in the 8021q code, 426 * c. Holding a lock with BH disabled while directly calling a base driver 427 * entry point is generally a BAD idea. 428 * 429 * The design of synchronization/protection for this operation in the 8021q 430 * module is good for one or more VLAN devices over a single physical device 431 * and cannot be extended for a teaming solution like bonding, so there is a 432 * potential race condition here where a net device from the vlan group might 433 * be referenced (either by a base driver or the 8021q code) while it is being 434 * removed from the system. However, it turns out we're not making matters 435 * worse, and if it works for regular VLAN usage it will work here too. 436 */ 437 438 /** 439 * bond_vlan_rx_register - Propagates registration to slaves 440 * @bond_dev: bonding net device that got called 441 * @grp: vlan group being registered 442 */ 443 static void bond_vlan_rx_register(struct net_device *bond_dev, struct vlan_group *grp) 444 { 445 struct bonding *bond = bond_dev->priv; 446 struct slave *slave; 447 int i; 448 449 bond->vlgrp = grp; 450 451 bond_for_each_slave(bond, slave, i) { 452 struct net_device *slave_dev = slave->dev; 453 454 if ((slave_dev->features & NETIF_F_HW_VLAN_RX) && 455 slave_dev->vlan_rx_register) { 456 slave_dev->vlan_rx_register(slave_dev, grp); 457 } 458 } 459 } 460 461 /** 462 * bond_vlan_rx_add_vid - Propagates adding an id to slaves 463 * @bond_dev: bonding net device that got called 464 * @vid: vlan id being added 465 */ 466 static void bond_vlan_rx_add_vid(struct net_device *bond_dev, uint16_t vid) 467 { 468 struct bonding *bond = bond_dev->priv; 469 struct slave *slave; 470 int i, res; 471 472 bond_for_each_slave(bond, slave, i) { 473 struct net_device *slave_dev = slave->dev; 474 475 if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) && 476 slave_dev->vlan_rx_add_vid) { 477 slave_dev->vlan_rx_add_vid(slave_dev, vid); 478 } 479 } 480 481 res = bond_add_vlan(bond, vid); 482 if (res) { 483 printk(KERN_ERR DRV_NAME 484 ": %s: Error: Failed to add vlan id %d\n", 485 bond_dev->name, vid); 486 } 487 } 488 489 /** 490 * bond_vlan_rx_kill_vid - Propagates deleting an id to slaves 491 * @bond_dev: bonding net device that got called 492 * @vid: vlan id being removed 493 */ 494 static void bond_vlan_rx_kill_vid(struct net_device *bond_dev, uint16_t vid) 495 { 496 struct bonding *bond = bond_dev->priv; 497 struct slave *slave; 498 struct net_device *vlan_dev; 499 int i, res; 500 501 bond_for_each_slave(bond, slave, i) { 502 struct net_device *slave_dev = slave->dev; 503 504 if ((slave_dev->features & NETIF_F_HW_VLAN_FILTER) && 505 slave_dev->vlan_rx_kill_vid) { 506 /* Save and then restore vlan_dev in the grp array, 507 * since the slave's driver might clear it. 508 */ 509 vlan_dev = vlan_group_get_device(bond->vlgrp, vid); 510 slave_dev->vlan_rx_kill_vid(slave_dev, vid); 511 vlan_group_set_device(bond->vlgrp, vid, vlan_dev); 512 } 513 } 514 515 res = bond_del_vlan(bond, vid); 516 if (res) { 517 printk(KERN_ERR DRV_NAME 518 ": %s: Error: Failed to remove vlan id %d\n", 519 bond_dev->name, vid); 520 } 521 } 522 523 static void bond_add_vlans_on_slave(struct bonding *bond, struct net_device *slave_dev) 524 { 525 struct vlan_entry *vlan; 526 527 write_lock_bh(&bond->lock); 528 529 if (list_empty(&bond->vlan_list)) { 530 goto out; 531 } 532 533 if ((slave_dev->features & NETIF_F_HW_VLAN_RX) && 534 slave_dev->vlan_rx_register) { 535 slave_dev->vlan_rx_register(slave_dev, bond->vlgrp); 536 } 537 538 if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) || 539 !(slave_dev->vlan_rx_add_vid)) { 540 goto out; 541 } 542 543 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) { 544 slave_dev->vlan_rx_add_vid(slave_dev, vlan->vlan_id); 545 } 546 547 out: 548 write_unlock_bh(&bond->lock); 549 } 550 551 static void bond_del_vlans_from_slave(struct bonding *bond, struct net_device *slave_dev) 552 { 553 struct vlan_entry *vlan; 554 struct net_device *vlan_dev; 555 556 write_lock_bh(&bond->lock); 557 558 if (list_empty(&bond->vlan_list)) { 559 goto out; 560 } 561 562 if (!(slave_dev->features & NETIF_F_HW_VLAN_FILTER) || 563 !(slave_dev->vlan_rx_kill_vid)) { 564 goto unreg; 565 } 566 567 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) { 568 /* Save and then restore vlan_dev in the grp array, 569 * since the slave's driver might clear it. 570 */ 571 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id); 572 slave_dev->vlan_rx_kill_vid(slave_dev, vlan->vlan_id); 573 vlan_group_set_device(bond->vlgrp, vlan->vlan_id, vlan_dev); 574 } 575 576 unreg: 577 if ((slave_dev->features & NETIF_F_HW_VLAN_RX) && 578 slave_dev->vlan_rx_register) { 579 slave_dev->vlan_rx_register(slave_dev, NULL); 580 } 581 582 out: 583 write_unlock_bh(&bond->lock); 584 } 585 586 /*------------------------------- Link status -------------------------------*/ 587 588 /* 589 * Set the carrier state for the master according to the state of its 590 * slaves. If any slaves are up, the master is up. In 802.3ad mode, 591 * do special 802.3ad magic. 592 * 593 * Returns zero if carrier state does not change, nonzero if it does. 594 */ 595 static int bond_set_carrier(struct bonding *bond) 596 { 597 struct slave *slave; 598 int i; 599 600 if (bond->slave_cnt == 0) 601 goto down; 602 603 if (bond->params.mode == BOND_MODE_8023AD) 604 return bond_3ad_set_carrier(bond); 605 606 bond_for_each_slave(bond, slave, i) { 607 if (slave->link == BOND_LINK_UP) { 608 if (!netif_carrier_ok(bond->dev)) { 609 netif_carrier_on(bond->dev); 610 return 1; 611 } 612 return 0; 613 } 614 } 615 616 down: 617 if (netif_carrier_ok(bond->dev)) { 618 netif_carrier_off(bond->dev); 619 return 1; 620 } 621 return 0; 622 } 623 624 /* 625 * Get link speed and duplex from the slave's base driver 626 * using ethtool. If for some reason the call fails or the 627 * values are invalid, fake speed and duplex to 100/Full 628 * and return error. 629 */ 630 static int bond_update_speed_duplex(struct slave *slave) 631 { 632 struct net_device *slave_dev = slave->dev; 633 struct ethtool_cmd etool; 634 int res; 635 636 /* Fake speed and duplex */ 637 slave->speed = SPEED_100; 638 slave->duplex = DUPLEX_FULL; 639 640 if (!slave_dev->ethtool_ops || !slave_dev->ethtool_ops->get_settings) 641 return -1; 642 643 res = slave_dev->ethtool_ops->get_settings(slave_dev, &etool); 644 if (res < 0) 645 return -1; 646 647 switch (etool.speed) { 648 case SPEED_10: 649 case SPEED_100: 650 case SPEED_1000: 651 case SPEED_10000: 652 break; 653 default: 654 return -1; 655 } 656 657 switch (etool.duplex) { 658 case DUPLEX_FULL: 659 case DUPLEX_HALF: 660 break; 661 default: 662 return -1; 663 } 664 665 slave->speed = etool.speed; 666 slave->duplex = etool.duplex; 667 668 return 0; 669 } 670 671 /* 672 * if <dev> supports MII link status reporting, check its link status. 673 * 674 * We either do MII/ETHTOOL ioctls, or check netif_carrier_ok(), 675 * depening upon the setting of the use_carrier parameter. 676 * 677 * Return either BMSR_LSTATUS, meaning that the link is up (or we 678 * can't tell and just pretend it is), or 0, meaning that the link is 679 * down. 680 * 681 * If reporting is non-zero, instead of faking link up, return -1 if 682 * both ETHTOOL and MII ioctls fail (meaning the device does not 683 * support them). If use_carrier is set, return whatever it says. 684 * It'd be nice if there was a good way to tell if a driver supports 685 * netif_carrier, but there really isn't. 686 */ 687 static int bond_check_dev_link(struct bonding *bond, struct net_device *slave_dev, int reporting) 688 { 689 static int (* ioctl)(struct net_device *, struct ifreq *, int); 690 struct ifreq ifr; 691 struct mii_ioctl_data *mii; 692 693 if (bond->params.use_carrier) { 694 return netif_carrier_ok(slave_dev) ? BMSR_LSTATUS : 0; 695 } 696 697 ioctl = slave_dev->do_ioctl; 698 if (ioctl) { 699 /* TODO: set pointer to correct ioctl on a per team member */ 700 /* bases to make this more efficient. that is, once */ 701 /* we determine the correct ioctl, we will always */ 702 /* call it and not the others for that team */ 703 /* member. */ 704 705 /* 706 * We cannot assume that SIOCGMIIPHY will also read a 707 * register; not all network drivers (e.g., e100) 708 * support that. 709 */ 710 711 /* Yes, the mii is overlaid on the ifreq.ifr_ifru */ 712 strncpy(ifr.ifr_name, slave_dev->name, IFNAMSIZ); 713 mii = if_mii(&ifr); 714 if (IOCTL(slave_dev, &ifr, SIOCGMIIPHY) == 0) { 715 mii->reg_num = MII_BMSR; 716 if (IOCTL(slave_dev, &ifr, SIOCGMIIREG) == 0) { 717 return (mii->val_out & BMSR_LSTATUS); 718 } 719 } 720 } 721 722 /* 723 * Some drivers cache ETHTOOL_GLINK for a period of time so we only 724 * attempt to get link status from it if the above MII ioctls fail. 725 */ 726 if (slave_dev->ethtool_ops) { 727 if (slave_dev->ethtool_ops->get_link) { 728 u32 link; 729 730 link = slave_dev->ethtool_ops->get_link(slave_dev); 731 732 return link ? BMSR_LSTATUS : 0; 733 } 734 } 735 736 /* 737 * If reporting, report that either there's no dev->do_ioctl, 738 * or both SIOCGMIIREG and get_link failed (meaning that we 739 * cannot report link status). If not reporting, pretend 740 * we're ok. 741 */ 742 return (reporting ? -1 : BMSR_LSTATUS); 743 } 744 745 /*----------------------------- Multicast list ------------------------------*/ 746 747 /* 748 * Returns 0 if dmi1 and dmi2 are the same, non-0 otherwise 749 */ 750 static inline int bond_is_dmi_same(struct dev_mc_list *dmi1, struct dev_mc_list *dmi2) 751 { 752 return memcmp(dmi1->dmi_addr, dmi2->dmi_addr, dmi1->dmi_addrlen) == 0 && 753 dmi1->dmi_addrlen == dmi2->dmi_addrlen; 754 } 755 756 /* 757 * returns dmi entry if found, NULL otherwise 758 */ 759 static struct dev_mc_list *bond_mc_list_find_dmi(struct dev_mc_list *dmi, struct dev_mc_list *mc_list) 760 { 761 struct dev_mc_list *idmi; 762 763 for (idmi = mc_list; idmi; idmi = idmi->next) { 764 if (bond_is_dmi_same(dmi, idmi)) { 765 return idmi; 766 } 767 } 768 769 return NULL; 770 } 771 772 /* 773 * Push the promiscuity flag down to appropriate slaves 774 */ 775 static int bond_set_promiscuity(struct bonding *bond, int inc) 776 { 777 int err = 0; 778 if (USES_PRIMARY(bond->params.mode)) { 779 /* write lock already acquired */ 780 if (bond->curr_active_slave) { 781 err = dev_set_promiscuity(bond->curr_active_slave->dev, 782 inc); 783 } 784 } else { 785 struct slave *slave; 786 int i; 787 bond_for_each_slave(bond, slave, i) { 788 err = dev_set_promiscuity(slave->dev, inc); 789 if (err) 790 return err; 791 } 792 } 793 return err; 794 } 795 796 /* 797 * Push the allmulti flag down to all slaves 798 */ 799 static int bond_set_allmulti(struct bonding *bond, int inc) 800 { 801 int err = 0; 802 if (USES_PRIMARY(bond->params.mode)) { 803 /* write lock already acquired */ 804 if (bond->curr_active_slave) { 805 err = dev_set_allmulti(bond->curr_active_slave->dev, 806 inc); 807 } 808 } else { 809 struct slave *slave; 810 int i; 811 bond_for_each_slave(bond, slave, i) { 812 err = dev_set_allmulti(slave->dev, inc); 813 if (err) 814 return err; 815 } 816 } 817 return err; 818 } 819 820 /* 821 * Add a Multicast address to slaves 822 * according to mode 823 */ 824 static void bond_mc_add(struct bonding *bond, void *addr, int alen) 825 { 826 if (USES_PRIMARY(bond->params.mode)) { 827 /* write lock already acquired */ 828 if (bond->curr_active_slave) { 829 dev_mc_add(bond->curr_active_slave->dev, addr, alen, 0); 830 } 831 } else { 832 struct slave *slave; 833 int i; 834 bond_for_each_slave(bond, slave, i) { 835 dev_mc_add(slave->dev, addr, alen, 0); 836 } 837 } 838 } 839 840 /* 841 * Remove a multicast address from slave 842 * according to mode 843 */ 844 static void bond_mc_delete(struct bonding *bond, void *addr, int alen) 845 { 846 if (USES_PRIMARY(bond->params.mode)) { 847 /* write lock already acquired */ 848 if (bond->curr_active_slave) { 849 dev_mc_delete(bond->curr_active_slave->dev, addr, alen, 0); 850 } 851 } else { 852 struct slave *slave; 853 int i; 854 bond_for_each_slave(bond, slave, i) { 855 dev_mc_delete(slave->dev, addr, alen, 0); 856 } 857 } 858 } 859 860 861 /* 862 * Retrieve the list of registered multicast addresses for the bonding 863 * device and retransmit an IGMP JOIN request to the current active 864 * slave. 865 */ 866 static void bond_resend_igmp_join_requests(struct bonding *bond) 867 { 868 struct in_device *in_dev; 869 struct ip_mc_list *im; 870 871 rcu_read_lock(); 872 in_dev = __in_dev_get_rcu(bond->dev); 873 if (in_dev) { 874 for (im = in_dev->mc_list; im; im = im->next) { 875 ip_mc_rejoin_group(im); 876 } 877 } 878 879 rcu_read_unlock(); 880 } 881 882 /* 883 * Totally destroys the mc_list in bond 884 */ 885 static void bond_mc_list_destroy(struct bonding *bond) 886 { 887 struct dev_mc_list *dmi; 888 889 dmi = bond->mc_list; 890 while (dmi) { 891 bond->mc_list = dmi->next; 892 kfree(dmi); 893 dmi = bond->mc_list; 894 } 895 bond->mc_list = NULL; 896 } 897 898 /* 899 * Copy all the Multicast addresses from src to the bonding device dst 900 */ 901 static int bond_mc_list_copy(struct dev_mc_list *mc_list, struct bonding *bond, 902 gfp_t gfp_flag) 903 { 904 struct dev_mc_list *dmi, *new_dmi; 905 906 for (dmi = mc_list; dmi; dmi = dmi->next) { 907 new_dmi = kmalloc(sizeof(struct dev_mc_list), gfp_flag); 908 909 if (!new_dmi) { 910 /* FIXME: Potential memory leak !!! */ 911 return -ENOMEM; 912 } 913 914 new_dmi->next = bond->mc_list; 915 bond->mc_list = new_dmi; 916 new_dmi->dmi_addrlen = dmi->dmi_addrlen; 917 memcpy(new_dmi->dmi_addr, dmi->dmi_addr, dmi->dmi_addrlen); 918 new_dmi->dmi_users = dmi->dmi_users; 919 new_dmi->dmi_gusers = dmi->dmi_gusers; 920 } 921 922 return 0; 923 } 924 925 /* 926 * flush all members of flush->mc_list from device dev->mc_list 927 */ 928 static void bond_mc_list_flush(struct net_device *bond_dev, struct net_device *slave_dev) 929 { 930 struct bonding *bond = bond_dev->priv; 931 struct dev_mc_list *dmi; 932 933 for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) { 934 dev_mc_delete(slave_dev, dmi->dmi_addr, dmi->dmi_addrlen, 0); 935 } 936 937 if (bond->params.mode == BOND_MODE_8023AD) { 938 /* del lacpdu mc addr from mc list */ 939 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR; 940 941 dev_mc_delete(slave_dev, lacpdu_multicast, ETH_ALEN, 0); 942 } 943 } 944 945 /*--------------------------- Active slave change ---------------------------*/ 946 947 /* 948 * Update the mc list and multicast-related flags for the new and 949 * old active slaves (if any) according to the multicast mode, and 950 * promiscuous flags unconditionally. 951 */ 952 static void bond_mc_swap(struct bonding *bond, struct slave *new_active, struct slave *old_active) 953 { 954 struct dev_mc_list *dmi; 955 956 if (!USES_PRIMARY(bond->params.mode)) { 957 /* nothing to do - mc list is already up-to-date on 958 * all slaves 959 */ 960 return; 961 } 962 963 if (old_active) { 964 if (bond->dev->flags & IFF_PROMISC) { 965 dev_set_promiscuity(old_active->dev, -1); 966 } 967 968 if (bond->dev->flags & IFF_ALLMULTI) { 969 dev_set_allmulti(old_active->dev, -1); 970 } 971 972 for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) { 973 dev_mc_delete(old_active->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0); 974 } 975 } 976 977 if (new_active) { 978 /* FIXME: Signal errors upstream. */ 979 if (bond->dev->flags & IFF_PROMISC) { 980 dev_set_promiscuity(new_active->dev, 1); 981 } 982 983 if (bond->dev->flags & IFF_ALLMULTI) { 984 dev_set_allmulti(new_active->dev, 1); 985 } 986 987 for (dmi = bond->dev->mc_list; dmi; dmi = dmi->next) { 988 dev_mc_add(new_active->dev, dmi->dmi_addr, dmi->dmi_addrlen, 0); 989 } 990 bond_resend_igmp_join_requests(bond); 991 } 992 } 993 994 /* 995 * bond_do_fail_over_mac 996 * 997 * Perform special MAC address swapping for fail_over_mac settings 998 * 999 * Called with RTNL, bond->lock for read, curr_slave_lock for write_bh. 1000 */ 1001 static void bond_do_fail_over_mac(struct bonding *bond, 1002 struct slave *new_active, 1003 struct slave *old_active) 1004 { 1005 u8 tmp_mac[ETH_ALEN]; 1006 struct sockaddr saddr; 1007 int rv; 1008 1009 switch (bond->params.fail_over_mac) { 1010 case BOND_FOM_ACTIVE: 1011 if (new_active) 1012 memcpy(bond->dev->dev_addr, new_active->dev->dev_addr, 1013 new_active->dev->addr_len); 1014 break; 1015 case BOND_FOM_FOLLOW: 1016 /* 1017 * if new_active && old_active, swap them 1018 * if just old_active, do nothing (going to no active slave) 1019 * if just new_active, set new_active to bond's MAC 1020 */ 1021 if (!new_active) 1022 return; 1023 1024 write_unlock_bh(&bond->curr_slave_lock); 1025 read_unlock(&bond->lock); 1026 1027 if (old_active) { 1028 memcpy(tmp_mac, new_active->dev->dev_addr, ETH_ALEN); 1029 memcpy(saddr.sa_data, old_active->dev->dev_addr, 1030 ETH_ALEN); 1031 saddr.sa_family = new_active->dev->type; 1032 } else { 1033 memcpy(saddr.sa_data, bond->dev->dev_addr, ETH_ALEN); 1034 saddr.sa_family = bond->dev->type; 1035 } 1036 1037 rv = dev_set_mac_address(new_active->dev, &saddr); 1038 if (rv) { 1039 printk(KERN_ERR DRV_NAME 1040 ": %s: Error %d setting MAC of slave %s\n", 1041 bond->dev->name, -rv, new_active->dev->name); 1042 goto out; 1043 } 1044 1045 if (!old_active) 1046 goto out; 1047 1048 memcpy(saddr.sa_data, tmp_mac, ETH_ALEN); 1049 saddr.sa_family = old_active->dev->type; 1050 1051 rv = dev_set_mac_address(old_active->dev, &saddr); 1052 if (rv) 1053 printk(KERN_ERR DRV_NAME 1054 ": %s: Error %d setting MAC of slave %s\n", 1055 bond->dev->name, -rv, new_active->dev->name); 1056 out: 1057 read_lock(&bond->lock); 1058 write_lock_bh(&bond->curr_slave_lock); 1059 break; 1060 default: 1061 printk(KERN_ERR DRV_NAME 1062 ": %s: bond_do_fail_over_mac impossible: bad policy %d\n", 1063 bond->dev->name, bond->params.fail_over_mac); 1064 break; 1065 } 1066 1067 } 1068 1069 1070 /** 1071 * find_best_interface - select the best available slave to be the active one 1072 * @bond: our bonding struct 1073 * 1074 * Warning: Caller must hold curr_slave_lock for writing. 1075 */ 1076 static struct slave *bond_find_best_slave(struct bonding *bond) 1077 { 1078 struct slave *new_active, *old_active; 1079 struct slave *bestslave = NULL; 1080 int mintime = bond->params.updelay; 1081 int i; 1082 1083 new_active = old_active = bond->curr_active_slave; 1084 1085 if (!new_active) { /* there were no active slaves left */ 1086 if (bond->slave_cnt > 0) { /* found one slave */ 1087 new_active = bond->first_slave; 1088 } else { 1089 return NULL; /* still no slave, return NULL */ 1090 } 1091 } 1092 1093 /* first try the primary link; if arping, a link must tx/rx traffic 1094 * before it can be considered the curr_active_slave - also, we would skip 1095 * slaves between the curr_active_slave and primary_slave that may be up 1096 * and able to arp 1097 */ 1098 if ((bond->primary_slave) && 1099 (!bond->params.arp_interval) && 1100 (IS_UP(bond->primary_slave->dev))) { 1101 new_active = bond->primary_slave; 1102 } 1103 1104 /* remember where to stop iterating over the slaves */ 1105 old_active = new_active; 1106 1107 bond_for_each_slave_from(bond, new_active, i, old_active) { 1108 if (IS_UP(new_active->dev)) { 1109 if (new_active->link == BOND_LINK_UP) { 1110 return new_active; 1111 } else if (new_active->link == BOND_LINK_BACK) { 1112 /* link up, but waiting for stabilization */ 1113 if (new_active->delay < mintime) { 1114 mintime = new_active->delay; 1115 bestslave = new_active; 1116 } 1117 } 1118 } 1119 } 1120 1121 return bestslave; 1122 } 1123 1124 /** 1125 * change_active_interface - change the active slave into the specified one 1126 * @bond: our bonding struct 1127 * @new: the new slave to make the active one 1128 * 1129 * Set the new slave to the bond's settings and unset them on the old 1130 * curr_active_slave. 1131 * Setting include flags, mc-list, promiscuity, allmulti, etc. 1132 * 1133 * If @new's link state is %BOND_LINK_BACK we'll set it to %BOND_LINK_UP, 1134 * because it is apparently the best available slave we have, even though its 1135 * updelay hasn't timed out yet. 1136 * 1137 * If new_active is not NULL, caller must hold bond->lock for read and 1138 * curr_slave_lock for write_bh. 1139 */ 1140 void bond_change_active_slave(struct bonding *bond, struct slave *new_active) 1141 { 1142 struct slave *old_active = bond->curr_active_slave; 1143 1144 if (old_active == new_active) { 1145 return; 1146 } 1147 1148 if (new_active) { 1149 new_active->jiffies = jiffies; 1150 1151 if (new_active->link == BOND_LINK_BACK) { 1152 if (USES_PRIMARY(bond->params.mode)) { 1153 printk(KERN_INFO DRV_NAME 1154 ": %s: making interface %s the new " 1155 "active one %d ms earlier.\n", 1156 bond->dev->name, new_active->dev->name, 1157 (bond->params.updelay - new_active->delay) * bond->params.miimon); 1158 } 1159 1160 new_active->delay = 0; 1161 new_active->link = BOND_LINK_UP; 1162 1163 if (bond->params.mode == BOND_MODE_8023AD) { 1164 bond_3ad_handle_link_change(new_active, BOND_LINK_UP); 1165 } 1166 1167 if ((bond->params.mode == BOND_MODE_TLB) || 1168 (bond->params.mode == BOND_MODE_ALB)) { 1169 bond_alb_handle_link_change(bond, new_active, BOND_LINK_UP); 1170 } 1171 } else { 1172 if (USES_PRIMARY(bond->params.mode)) { 1173 printk(KERN_INFO DRV_NAME 1174 ": %s: making interface %s the new " 1175 "active one.\n", 1176 bond->dev->name, new_active->dev->name); 1177 } 1178 } 1179 } 1180 1181 if (USES_PRIMARY(bond->params.mode)) { 1182 bond_mc_swap(bond, new_active, old_active); 1183 } 1184 1185 if ((bond->params.mode == BOND_MODE_TLB) || 1186 (bond->params.mode == BOND_MODE_ALB)) { 1187 bond_alb_handle_active_change(bond, new_active); 1188 if (old_active) 1189 bond_set_slave_inactive_flags(old_active); 1190 if (new_active) 1191 bond_set_slave_active_flags(new_active); 1192 } else { 1193 bond->curr_active_slave = new_active; 1194 } 1195 1196 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) { 1197 if (old_active) { 1198 bond_set_slave_inactive_flags(old_active); 1199 } 1200 1201 if (new_active) { 1202 bond_set_slave_active_flags(new_active); 1203 1204 if (bond->params.fail_over_mac) 1205 bond_do_fail_over_mac(bond, new_active, 1206 old_active); 1207 1208 bond->send_grat_arp = bond->params.num_grat_arp; 1209 bond_send_gratuitous_arp(bond); 1210 1211 write_unlock_bh(&bond->curr_slave_lock); 1212 read_unlock(&bond->lock); 1213 1214 netdev_bonding_change(bond->dev); 1215 1216 read_lock(&bond->lock); 1217 write_lock_bh(&bond->curr_slave_lock); 1218 } 1219 } 1220 } 1221 1222 /** 1223 * bond_select_active_slave - select a new active slave, if needed 1224 * @bond: our bonding struct 1225 * 1226 * This functions shoud be called when one of the following occurs: 1227 * - The old curr_active_slave has been released or lost its link. 1228 * - The primary_slave has got its link back. 1229 * - A slave has got its link back and there's no old curr_active_slave. 1230 * 1231 * Caller must hold bond->lock for read and curr_slave_lock for write_bh. 1232 */ 1233 void bond_select_active_slave(struct bonding *bond) 1234 { 1235 struct slave *best_slave; 1236 int rv; 1237 1238 best_slave = bond_find_best_slave(bond); 1239 if (best_slave != bond->curr_active_slave) { 1240 bond_change_active_slave(bond, best_slave); 1241 rv = bond_set_carrier(bond); 1242 if (!rv) 1243 return; 1244 1245 if (netif_carrier_ok(bond->dev)) { 1246 printk(KERN_INFO DRV_NAME 1247 ": %s: first active interface up!\n", 1248 bond->dev->name); 1249 } else { 1250 printk(KERN_INFO DRV_NAME ": %s: " 1251 "now running without any active interface !\n", 1252 bond->dev->name); 1253 } 1254 } 1255 } 1256 1257 /*--------------------------- slave list handling ---------------------------*/ 1258 1259 /* 1260 * This function attaches the slave to the end of list. 1261 * 1262 * bond->lock held for writing by caller. 1263 */ 1264 static void bond_attach_slave(struct bonding *bond, struct slave *new_slave) 1265 { 1266 if (bond->first_slave == NULL) { /* attaching the first slave */ 1267 new_slave->next = new_slave; 1268 new_slave->prev = new_slave; 1269 bond->first_slave = new_slave; 1270 } else { 1271 new_slave->next = bond->first_slave; 1272 new_slave->prev = bond->first_slave->prev; 1273 new_slave->next->prev = new_slave; 1274 new_slave->prev->next = new_slave; 1275 } 1276 1277 bond->slave_cnt++; 1278 } 1279 1280 /* 1281 * This function detaches the slave from the list. 1282 * WARNING: no check is made to verify if the slave effectively 1283 * belongs to <bond>. 1284 * Nothing is freed on return, structures are just unchained. 1285 * If any slave pointer in bond was pointing to <slave>, 1286 * it should be changed by the calling function. 1287 * 1288 * bond->lock held for writing by caller. 1289 */ 1290 static void bond_detach_slave(struct bonding *bond, struct slave *slave) 1291 { 1292 if (slave->next) { 1293 slave->next->prev = slave->prev; 1294 } 1295 1296 if (slave->prev) { 1297 slave->prev->next = slave->next; 1298 } 1299 1300 if (bond->first_slave == slave) { /* slave is the first slave */ 1301 if (bond->slave_cnt > 1) { /* there are more slave */ 1302 bond->first_slave = slave->next; 1303 } else { 1304 bond->first_slave = NULL; /* slave was the last one */ 1305 } 1306 } 1307 1308 slave->next = NULL; 1309 slave->prev = NULL; 1310 bond->slave_cnt--; 1311 } 1312 1313 /*---------------------------------- IOCTL ----------------------------------*/ 1314 1315 static int bond_sethwaddr(struct net_device *bond_dev, 1316 struct net_device *slave_dev) 1317 { 1318 dprintk("bond_dev=%p\n", bond_dev); 1319 dprintk("slave_dev=%p\n", slave_dev); 1320 dprintk("slave_dev->addr_len=%d\n", slave_dev->addr_len); 1321 memcpy(bond_dev->dev_addr, slave_dev->dev_addr, slave_dev->addr_len); 1322 return 0; 1323 } 1324 1325 #define BOND_VLAN_FEATURES \ 1326 (NETIF_F_VLAN_CHALLENGED | NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_TX | \ 1327 NETIF_F_HW_VLAN_FILTER) 1328 1329 /* 1330 * Compute the common dev->feature set available to all slaves. Some 1331 * feature bits are managed elsewhere, so preserve those feature bits 1332 * on the master device. 1333 */ 1334 static int bond_compute_features(struct bonding *bond) 1335 { 1336 struct slave *slave; 1337 struct net_device *bond_dev = bond->dev; 1338 unsigned long features = bond_dev->features; 1339 unsigned short max_hard_header_len = max((u16)ETH_HLEN, 1340 bond_dev->hard_header_len); 1341 int i; 1342 1343 features &= ~(NETIF_F_ALL_CSUM | BOND_VLAN_FEATURES); 1344 features |= NETIF_F_GSO_MASK | NETIF_F_NO_CSUM; 1345 1346 if (!bond->first_slave) 1347 goto done; 1348 1349 features &= ~NETIF_F_ONE_FOR_ALL; 1350 1351 bond_for_each_slave(bond, slave, i) { 1352 features = netdev_increment_features(features, 1353 slave->dev->features, 1354 NETIF_F_ONE_FOR_ALL); 1355 if (slave->dev->hard_header_len > max_hard_header_len) 1356 max_hard_header_len = slave->dev->hard_header_len; 1357 } 1358 1359 done: 1360 features |= (bond_dev->features & BOND_VLAN_FEATURES); 1361 bond_dev->features = netdev_fix_features(features, NULL); 1362 bond_dev->hard_header_len = max_hard_header_len; 1363 1364 return 0; 1365 } 1366 1367 1368 static void bond_setup_by_slave(struct net_device *bond_dev, 1369 struct net_device *slave_dev) 1370 { 1371 struct bonding *bond = bond_dev->priv; 1372 1373 bond_dev->neigh_setup = slave_dev->neigh_setup; 1374 bond_dev->header_ops = slave_dev->header_ops; 1375 1376 bond_dev->type = slave_dev->type; 1377 bond_dev->hard_header_len = slave_dev->hard_header_len; 1378 bond_dev->addr_len = slave_dev->addr_len; 1379 1380 memcpy(bond_dev->broadcast, slave_dev->broadcast, 1381 slave_dev->addr_len); 1382 bond->setup_by_slave = 1; 1383 } 1384 1385 /* enslave device <slave> to bond device <master> */ 1386 int bond_enslave(struct net_device *bond_dev, struct net_device *slave_dev) 1387 { 1388 struct bonding *bond = bond_dev->priv; 1389 struct slave *new_slave = NULL; 1390 struct dev_mc_list *dmi; 1391 struct sockaddr addr; 1392 int link_reporting; 1393 int old_features = bond_dev->features; 1394 int res = 0; 1395 1396 if (!bond->params.use_carrier && slave_dev->ethtool_ops == NULL && 1397 slave_dev->do_ioctl == NULL) { 1398 printk(KERN_WARNING DRV_NAME 1399 ": %s: Warning: no link monitoring support for %s\n", 1400 bond_dev->name, slave_dev->name); 1401 } 1402 1403 /* bond must be initialized by bond_open() before enslaving */ 1404 if (!(bond_dev->flags & IFF_UP)) { 1405 printk(KERN_WARNING DRV_NAME 1406 " %s: master_dev is not up in bond_enslave\n", 1407 bond_dev->name); 1408 } 1409 1410 /* already enslaved */ 1411 if (slave_dev->flags & IFF_SLAVE) { 1412 dprintk("Error, Device was already enslaved\n"); 1413 return -EBUSY; 1414 } 1415 1416 /* vlan challenged mutual exclusion */ 1417 /* no need to lock since we're protected by rtnl_lock */ 1418 if (slave_dev->features & NETIF_F_VLAN_CHALLENGED) { 1419 dprintk("%s: NETIF_F_VLAN_CHALLENGED\n", slave_dev->name); 1420 if (!list_empty(&bond->vlan_list)) { 1421 printk(KERN_ERR DRV_NAME 1422 ": %s: Error: cannot enslave VLAN " 1423 "challenged slave %s on VLAN enabled " 1424 "bond %s\n", bond_dev->name, slave_dev->name, 1425 bond_dev->name); 1426 return -EPERM; 1427 } else { 1428 printk(KERN_WARNING DRV_NAME 1429 ": %s: Warning: enslaved VLAN challenged " 1430 "slave %s. Adding VLANs will be blocked as " 1431 "long as %s is part of bond %s\n", 1432 bond_dev->name, slave_dev->name, slave_dev->name, 1433 bond_dev->name); 1434 bond_dev->features |= NETIF_F_VLAN_CHALLENGED; 1435 } 1436 } else { 1437 dprintk("%s: ! NETIF_F_VLAN_CHALLENGED\n", slave_dev->name); 1438 if (bond->slave_cnt == 0) { 1439 /* First slave, and it is not VLAN challenged, 1440 * so remove the block of adding VLANs over the bond. 1441 */ 1442 bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED; 1443 } 1444 } 1445 1446 /* 1447 * Old ifenslave binaries are no longer supported. These can 1448 * be identified with moderate accurary by the state of the slave: 1449 * the current ifenslave will set the interface down prior to 1450 * enslaving it; the old ifenslave will not. 1451 */ 1452 if ((slave_dev->flags & IFF_UP)) { 1453 printk(KERN_ERR DRV_NAME ": %s is up. " 1454 "This may be due to an out of date ifenslave.\n", 1455 slave_dev->name); 1456 res = -EPERM; 1457 goto err_undo_flags; 1458 } 1459 1460 /* set bonding device ether type by slave - bonding netdevices are 1461 * created with ether_setup, so when the slave type is not ARPHRD_ETHER 1462 * there is a need to override some of the type dependent attribs/funcs. 1463 * 1464 * bond ether type mutual exclusion - don't allow slaves of dissimilar 1465 * ether type (eg ARPHRD_ETHER and ARPHRD_INFINIBAND) share the same bond 1466 */ 1467 if (bond->slave_cnt == 0) { 1468 if (slave_dev->type != ARPHRD_ETHER) 1469 bond_setup_by_slave(bond_dev, slave_dev); 1470 } else if (bond_dev->type != slave_dev->type) { 1471 printk(KERN_ERR DRV_NAME ": %s ether type (%d) is different " 1472 "from other slaves (%d), can not enslave it.\n", 1473 slave_dev->name, 1474 slave_dev->type, bond_dev->type); 1475 res = -EINVAL; 1476 goto err_undo_flags; 1477 } 1478 1479 if (slave_dev->set_mac_address == NULL) { 1480 if (bond->slave_cnt == 0) { 1481 printk(KERN_WARNING DRV_NAME 1482 ": %s: Warning: The first slave device " 1483 "specified does not support setting the MAC " 1484 "address. Setting fail_over_mac to active.", 1485 bond_dev->name); 1486 bond->params.fail_over_mac = BOND_FOM_ACTIVE; 1487 } else if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) { 1488 printk(KERN_ERR DRV_NAME 1489 ": %s: Error: The slave device specified " 1490 "does not support setting the MAC address, " 1491 "but fail_over_mac is not set to active.\n" 1492 , bond_dev->name); 1493 res = -EOPNOTSUPP; 1494 goto err_undo_flags; 1495 } 1496 } 1497 1498 new_slave = kzalloc(sizeof(struct slave), GFP_KERNEL); 1499 if (!new_slave) { 1500 res = -ENOMEM; 1501 goto err_undo_flags; 1502 } 1503 1504 /* save slave's original flags before calling 1505 * netdev_set_master and dev_open 1506 */ 1507 new_slave->original_flags = slave_dev->flags; 1508 1509 /* 1510 * Save slave's original ("permanent") mac address for modes 1511 * that need it, and for restoring it upon release, and then 1512 * set it to the master's address 1513 */ 1514 memcpy(new_slave->perm_hwaddr, slave_dev->dev_addr, ETH_ALEN); 1515 1516 if (!bond->params.fail_over_mac) { 1517 /* 1518 * Set slave to master's mac address. The application already 1519 * set the master's mac address to that of the first slave 1520 */ 1521 memcpy(addr.sa_data, bond_dev->dev_addr, bond_dev->addr_len); 1522 addr.sa_family = slave_dev->type; 1523 res = dev_set_mac_address(slave_dev, &addr); 1524 if (res) { 1525 dprintk("Error %d calling set_mac_address\n", res); 1526 goto err_free; 1527 } 1528 } 1529 1530 res = netdev_set_master(slave_dev, bond_dev); 1531 if (res) { 1532 dprintk("Error %d calling netdev_set_master\n", res); 1533 goto err_restore_mac; 1534 } 1535 /* open the slave since the application closed it */ 1536 res = dev_open(slave_dev); 1537 if (res) { 1538 dprintk("Openning slave %s failed\n", slave_dev->name); 1539 goto err_unset_master; 1540 } 1541 1542 new_slave->dev = slave_dev; 1543 slave_dev->priv_flags |= IFF_BONDING; 1544 1545 if ((bond->params.mode == BOND_MODE_TLB) || 1546 (bond->params.mode == BOND_MODE_ALB)) { 1547 /* bond_alb_init_slave() must be called before all other stages since 1548 * it might fail and we do not want to have to undo everything 1549 */ 1550 res = bond_alb_init_slave(bond, new_slave); 1551 if (res) { 1552 goto err_close; 1553 } 1554 } 1555 1556 /* If the mode USES_PRIMARY, then the new slave gets the 1557 * master's promisc (and mc) settings only if it becomes the 1558 * curr_active_slave, and that is taken care of later when calling 1559 * bond_change_active() 1560 */ 1561 if (!USES_PRIMARY(bond->params.mode)) { 1562 /* set promiscuity level to new slave */ 1563 if (bond_dev->flags & IFF_PROMISC) { 1564 res = dev_set_promiscuity(slave_dev, 1); 1565 if (res) 1566 goto err_close; 1567 } 1568 1569 /* set allmulti level to new slave */ 1570 if (bond_dev->flags & IFF_ALLMULTI) { 1571 res = dev_set_allmulti(slave_dev, 1); 1572 if (res) 1573 goto err_close; 1574 } 1575 1576 netif_addr_lock_bh(bond_dev); 1577 /* upload master's mc_list to new slave */ 1578 for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) { 1579 dev_mc_add (slave_dev, dmi->dmi_addr, dmi->dmi_addrlen, 0); 1580 } 1581 netif_addr_unlock_bh(bond_dev); 1582 } 1583 1584 if (bond->params.mode == BOND_MODE_8023AD) { 1585 /* add lacpdu mc addr to mc list */ 1586 u8 lacpdu_multicast[ETH_ALEN] = MULTICAST_LACPDU_ADDR; 1587 1588 dev_mc_add(slave_dev, lacpdu_multicast, ETH_ALEN, 0); 1589 } 1590 1591 bond_add_vlans_on_slave(bond, slave_dev); 1592 1593 write_lock_bh(&bond->lock); 1594 1595 bond_attach_slave(bond, new_slave); 1596 1597 new_slave->delay = 0; 1598 new_slave->link_failure_count = 0; 1599 1600 bond_compute_features(bond); 1601 1602 write_unlock_bh(&bond->lock); 1603 1604 read_lock(&bond->lock); 1605 1606 new_slave->last_arp_rx = jiffies; 1607 1608 if (bond->params.miimon && !bond->params.use_carrier) { 1609 link_reporting = bond_check_dev_link(bond, slave_dev, 1); 1610 1611 if ((link_reporting == -1) && !bond->params.arp_interval) { 1612 /* 1613 * miimon is set but a bonded network driver 1614 * does not support ETHTOOL/MII and 1615 * arp_interval is not set. Note: if 1616 * use_carrier is enabled, we will never go 1617 * here (because netif_carrier is always 1618 * supported); thus, we don't need to change 1619 * the messages for netif_carrier. 1620 */ 1621 printk(KERN_WARNING DRV_NAME 1622 ": %s: Warning: MII and ETHTOOL support not " 1623 "available for interface %s, and " 1624 "arp_interval/arp_ip_target module parameters " 1625 "not specified, thus bonding will not detect " 1626 "link failures! see bonding.txt for details.\n", 1627 bond_dev->name, slave_dev->name); 1628 } else if (link_reporting == -1) { 1629 /* unable get link status using mii/ethtool */ 1630 printk(KERN_WARNING DRV_NAME 1631 ": %s: Warning: can't get link status from " 1632 "interface %s; the network driver associated " 1633 "with this interface does not support MII or " 1634 "ETHTOOL link status reporting, thus miimon " 1635 "has no effect on this interface.\n", 1636 bond_dev->name, slave_dev->name); 1637 } 1638 } 1639 1640 /* check for initial state */ 1641 if (!bond->params.miimon || 1642 (bond_check_dev_link(bond, slave_dev, 0) == BMSR_LSTATUS)) { 1643 if (bond->params.updelay) { 1644 dprintk("Initial state of slave_dev is " 1645 "BOND_LINK_BACK\n"); 1646 new_slave->link = BOND_LINK_BACK; 1647 new_slave->delay = bond->params.updelay; 1648 } else { 1649 dprintk("Initial state of slave_dev is " 1650 "BOND_LINK_UP\n"); 1651 new_slave->link = BOND_LINK_UP; 1652 } 1653 new_slave->jiffies = jiffies; 1654 } else { 1655 dprintk("Initial state of slave_dev is " 1656 "BOND_LINK_DOWN\n"); 1657 new_slave->link = BOND_LINK_DOWN; 1658 } 1659 1660 if (bond_update_speed_duplex(new_slave) && 1661 (new_slave->link != BOND_LINK_DOWN)) { 1662 printk(KERN_WARNING DRV_NAME 1663 ": %s: Warning: failed to get speed and duplex from %s, " 1664 "assumed to be 100Mb/sec and Full.\n", 1665 bond_dev->name, new_slave->dev->name); 1666 1667 if (bond->params.mode == BOND_MODE_8023AD) { 1668 printk(KERN_WARNING DRV_NAME 1669 ": %s: Warning: Operation of 802.3ad mode requires ETHTOOL " 1670 "support in base driver for proper aggregator " 1671 "selection.\n", bond_dev->name); 1672 } 1673 } 1674 1675 if (USES_PRIMARY(bond->params.mode) && bond->params.primary[0]) { 1676 /* if there is a primary slave, remember it */ 1677 if (strcmp(bond->params.primary, new_slave->dev->name) == 0) { 1678 bond->primary_slave = new_slave; 1679 } 1680 } 1681 1682 write_lock_bh(&bond->curr_slave_lock); 1683 1684 switch (bond->params.mode) { 1685 case BOND_MODE_ACTIVEBACKUP: 1686 bond_set_slave_inactive_flags(new_slave); 1687 bond_select_active_slave(bond); 1688 break; 1689 case BOND_MODE_8023AD: 1690 /* in 802.3ad mode, the internal mechanism 1691 * will activate the slaves in the selected 1692 * aggregator 1693 */ 1694 bond_set_slave_inactive_flags(new_slave); 1695 /* if this is the first slave */ 1696 if (bond->slave_cnt == 1) { 1697 SLAVE_AD_INFO(new_slave).id = 1; 1698 /* Initialize AD with the number of times that the AD timer is called in 1 second 1699 * can be called only after the mac address of the bond is set 1700 */ 1701 bond_3ad_initialize(bond, 1000/AD_TIMER_INTERVAL, 1702 bond->params.lacp_fast); 1703 } else { 1704 SLAVE_AD_INFO(new_slave).id = 1705 SLAVE_AD_INFO(new_slave->prev).id + 1; 1706 } 1707 1708 bond_3ad_bind_slave(new_slave); 1709 break; 1710 case BOND_MODE_TLB: 1711 case BOND_MODE_ALB: 1712 new_slave->state = BOND_STATE_ACTIVE; 1713 bond_set_slave_inactive_flags(new_slave); 1714 break; 1715 default: 1716 dprintk("This slave is always active in trunk mode\n"); 1717 1718 /* always active in trunk mode */ 1719 new_slave->state = BOND_STATE_ACTIVE; 1720 1721 /* In trunking mode there is little meaning to curr_active_slave 1722 * anyway (it holds no special properties of the bond device), 1723 * so we can change it without calling change_active_interface() 1724 */ 1725 if (!bond->curr_active_slave) { 1726 bond->curr_active_slave = new_slave; 1727 } 1728 break; 1729 } /* switch(bond_mode) */ 1730 1731 write_unlock_bh(&bond->curr_slave_lock); 1732 1733 bond_set_carrier(bond); 1734 1735 read_unlock(&bond->lock); 1736 1737 res = bond_create_slave_symlinks(bond_dev, slave_dev); 1738 if (res) 1739 goto err_close; 1740 1741 printk(KERN_INFO DRV_NAME 1742 ": %s: enslaving %s as a%s interface with a%s link.\n", 1743 bond_dev->name, slave_dev->name, 1744 new_slave->state == BOND_STATE_ACTIVE ? "n active" : " backup", 1745 new_slave->link != BOND_LINK_DOWN ? "n up" : " down"); 1746 1747 /* enslave is successful */ 1748 return 0; 1749 1750 /* Undo stages on error */ 1751 err_close: 1752 dev_close(slave_dev); 1753 1754 err_unset_master: 1755 netdev_set_master(slave_dev, NULL); 1756 1757 err_restore_mac: 1758 if (!bond->params.fail_over_mac) { 1759 /* XXX TODO - fom follow mode needs to change master's 1760 * MAC if this slave's MAC is in use by the bond, or at 1761 * least print a warning. 1762 */ 1763 memcpy(addr.sa_data, new_slave->perm_hwaddr, ETH_ALEN); 1764 addr.sa_family = slave_dev->type; 1765 dev_set_mac_address(slave_dev, &addr); 1766 } 1767 1768 err_free: 1769 kfree(new_slave); 1770 1771 err_undo_flags: 1772 bond_dev->features = old_features; 1773 1774 return res; 1775 } 1776 1777 /* 1778 * Try to release the slave device <slave> from the bond device <master> 1779 * It is legal to access curr_active_slave without a lock because all the function 1780 * is write-locked. 1781 * 1782 * The rules for slave state should be: 1783 * for Active/Backup: 1784 * Active stays on all backups go down 1785 * for Bonded connections: 1786 * The first up interface should be left on and all others downed. 1787 */ 1788 int bond_release(struct net_device *bond_dev, struct net_device *slave_dev) 1789 { 1790 struct bonding *bond = bond_dev->priv; 1791 struct slave *slave, *oldcurrent; 1792 struct sockaddr addr; 1793 int mac_addr_differ; 1794 DECLARE_MAC_BUF(mac); 1795 1796 /* slave is not a slave or master is not master of this slave */ 1797 if (!(slave_dev->flags & IFF_SLAVE) || 1798 (slave_dev->master != bond_dev)) { 1799 printk(KERN_ERR DRV_NAME 1800 ": %s: Error: cannot release %s.\n", 1801 bond_dev->name, slave_dev->name); 1802 return -EINVAL; 1803 } 1804 1805 write_lock_bh(&bond->lock); 1806 1807 slave = bond_get_slave_by_dev(bond, slave_dev); 1808 if (!slave) { 1809 /* not a slave of this bond */ 1810 printk(KERN_INFO DRV_NAME 1811 ": %s: %s not enslaved\n", 1812 bond_dev->name, slave_dev->name); 1813 write_unlock_bh(&bond->lock); 1814 return -EINVAL; 1815 } 1816 1817 if (!bond->params.fail_over_mac) { 1818 mac_addr_differ = memcmp(bond_dev->dev_addr, slave->perm_hwaddr, 1819 ETH_ALEN); 1820 if (!mac_addr_differ && (bond->slave_cnt > 1)) 1821 printk(KERN_WARNING DRV_NAME 1822 ": %s: Warning: the permanent HWaddr of %s - " 1823 "%s - is still in use by %s. " 1824 "Set the HWaddr of %s to a different address " 1825 "to avoid conflicts.\n", 1826 bond_dev->name, slave_dev->name, 1827 print_mac(mac, slave->perm_hwaddr), 1828 bond_dev->name, slave_dev->name); 1829 } 1830 1831 /* Inform AD package of unbinding of slave. */ 1832 if (bond->params.mode == BOND_MODE_8023AD) { 1833 /* must be called before the slave is 1834 * detached from the list 1835 */ 1836 bond_3ad_unbind_slave(slave); 1837 } 1838 1839 printk(KERN_INFO DRV_NAME 1840 ": %s: releasing %s interface %s\n", 1841 bond_dev->name, 1842 (slave->state == BOND_STATE_ACTIVE) 1843 ? "active" : "backup", 1844 slave_dev->name); 1845 1846 oldcurrent = bond->curr_active_slave; 1847 1848 bond->current_arp_slave = NULL; 1849 1850 /* release the slave from its bond */ 1851 bond_detach_slave(bond, slave); 1852 1853 bond_compute_features(bond); 1854 1855 if (bond->primary_slave == slave) { 1856 bond->primary_slave = NULL; 1857 } 1858 1859 if (oldcurrent == slave) { 1860 bond_change_active_slave(bond, NULL); 1861 } 1862 1863 if ((bond->params.mode == BOND_MODE_TLB) || 1864 (bond->params.mode == BOND_MODE_ALB)) { 1865 /* Must be called only after the slave has been 1866 * detached from the list and the curr_active_slave 1867 * has been cleared (if our_slave == old_current), 1868 * but before a new active slave is selected. 1869 */ 1870 write_unlock_bh(&bond->lock); 1871 bond_alb_deinit_slave(bond, slave); 1872 write_lock_bh(&bond->lock); 1873 } 1874 1875 if (oldcurrent == slave) { 1876 /* 1877 * Note that we hold RTNL over this sequence, so there 1878 * is no concern that another slave add/remove event 1879 * will interfere. 1880 */ 1881 write_unlock_bh(&bond->lock); 1882 read_lock(&bond->lock); 1883 write_lock_bh(&bond->curr_slave_lock); 1884 1885 bond_select_active_slave(bond); 1886 1887 write_unlock_bh(&bond->curr_slave_lock); 1888 read_unlock(&bond->lock); 1889 write_lock_bh(&bond->lock); 1890 } 1891 1892 if (bond->slave_cnt == 0) { 1893 bond_set_carrier(bond); 1894 1895 /* if the last slave was removed, zero the mac address 1896 * of the master so it will be set by the application 1897 * to the mac address of the first slave 1898 */ 1899 memset(bond_dev->dev_addr, 0, bond_dev->addr_len); 1900 1901 if (list_empty(&bond->vlan_list)) { 1902 bond_dev->features |= NETIF_F_VLAN_CHALLENGED; 1903 } else { 1904 printk(KERN_WARNING DRV_NAME 1905 ": %s: Warning: clearing HW address of %s while it " 1906 "still has VLANs.\n", 1907 bond_dev->name, bond_dev->name); 1908 printk(KERN_WARNING DRV_NAME 1909 ": %s: When re-adding slaves, make sure the bond's " 1910 "HW address matches its VLANs'.\n", 1911 bond_dev->name); 1912 } 1913 } else if ((bond_dev->features & NETIF_F_VLAN_CHALLENGED) && 1914 !bond_has_challenged_slaves(bond)) { 1915 printk(KERN_INFO DRV_NAME 1916 ": %s: last VLAN challenged slave %s " 1917 "left bond %s. VLAN blocking is removed\n", 1918 bond_dev->name, slave_dev->name, bond_dev->name); 1919 bond_dev->features &= ~NETIF_F_VLAN_CHALLENGED; 1920 } 1921 1922 write_unlock_bh(&bond->lock); 1923 1924 /* must do this from outside any spinlocks */ 1925 bond_destroy_slave_symlinks(bond_dev, slave_dev); 1926 1927 bond_del_vlans_from_slave(bond, slave_dev); 1928 1929 /* If the mode USES_PRIMARY, then we should only remove its 1930 * promisc and mc settings if it was the curr_active_slave, but that was 1931 * already taken care of above when we detached the slave 1932 */ 1933 if (!USES_PRIMARY(bond->params.mode)) { 1934 /* unset promiscuity level from slave */ 1935 if (bond_dev->flags & IFF_PROMISC) { 1936 dev_set_promiscuity(slave_dev, -1); 1937 } 1938 1939 /* unset allmulti level from slave */ 1940 if (bond_dev->flags & IFF_ALLMULTI) { 1941 dev_set_allmulti(slave_dev, -1); 1942 } 1943 1944 /* flush master's mc_list from slave */ 1945 netif_addr_lock_bh(bond_dev); 1946 bond_mc_list_flush(bond_dev, slave_dev); 1947 netif_addr_unlock_bh(bond_dev); 1948 } 1949 1950 netdev_set_master(slave_dev, NULL); 1951 1952 /* close slave before restoring its mac address */ 1953 dev_close(slave_dev); 1954 1955 if (bond->params.fail_over_mac != BOND_FOM_ACTIVE) { 1956 /* restore original ("permanent") mac address */ 1957 memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN); 1958 addr.sa_family = slave_dev->type; 1959 dev_set_mac_address(slave_dev, &addr); 1960 } 1961 1962 slave_dev->priv_flags &= ~(IFF_MASTER_8023AD | IFF_MASTER_ALB | 1963 IFF_SLAVE_INACTIVE | IFF_BONDING | 1964 IFF_SLAVE_NEEDARP); 1965 1966 kfree(slave); 1967 1968 return 0; /* deletion OK */ 1969 } 1970 1971 /* 1972 * Destroy a bonding device. 1973 * Must be under rtnl_lock when this function is called. 1974 */ 1975 void bond_destroy(struct bonding *bond) 1976 { 1977 bond_deinit(bond->dev); 1978 bond_destroy_sysfs_entry(bond); 1979 unregister_netdevice(bond->dev); 1980 } 1981 1982 /* 1983 * First release a slave and than destroy the bond if no more slaves iare left. 1984 * Must be under rtnl_lock when this function is called. 1985 */ 1986 int bond_release_and_destroy(struct net_device *bond_dev, struct net_device *slave_dev) 1987 { 1988 struct bonding *bond = bond_dev->priv; 1989 int ret; 1990 1991 ret = bond_release(bond_dev, slave_dev); 1992 if ((ret == 0) && (bond->slave_cnt == 0)) { 1993 printk(KERN_INFO DRV_NAME ": %s: destroying bond %s.\n", 1994 bond_dev->name, bond_dev->name); 1995 bond_destroy(bond); 1996 } 1997 return ret; 1998 } 1999 2000 /* 2001 * This function releases all slaves. 2002 */ 2003 static int bond_release_all(struct net_device *bond_dev) 2004 { 2005 struct bonding *bond = bond_dev->priv; 2006 struct slave *slave; 2007 struct net_device *slave_dev; 2008 struct sockaddr addr; 2009 2010 write_lock_bh(&bond->lock); 2011 2012 netif_carrier_off(bond_dev); 2013 2014 if (bond->slave_cnt == 0) { 2015 goto out; 2016 } 2017 2018 bond->current_arp_slave = NULL; 2019 bond->primary_slave = NULL; 2020 bond_change_active_slave(bond, NULL); 2021 2022 while ((slave = bond->first_slave) != NULL) { 2023 /* Inform AD package of unbinding of slave 2024 * before slave is detached from the list. 2025 */ 2026 if (bond->params.mode == BOND_MODE_8023AD) { 2027 bond_3ad_unbind_slave(slave); 2028 } 2029 2030 slave_dev = slave->dev; 2031 bond_detach_slave(bond, slave); 2032 2033 /* now that the slave is detached, unlock and perform 2034 * all the undo steps that should not be called from 2035 * within a lock. 2036 */ 2037 write_unlock_bh(&bond->lock); 2038 2039 if ((bond->params.mode == BOND_MODE_TLB) || 2040 (bond->params.mode == BOND_MODE_ALB)) { 2041 /* must be called only after the slave 2042 * has been detached from the list 2043 */ 2044 bond_alb_deinit_slave(bond, slave); 2045 } 2046 2047 bond_compute_features(bond); 2048 2049 bond_destroy_slave_symlinks(bond_dev, slave_dev); 2050 bond_del_vlans_from_slave(bond, slave_dev); 2051 2052 /* If the mode USES_PRIMARY, then we should only remove its 2053 * promisc and mc settings if it was the curr_active_slave, but that was 2054 * already taken care of above when we detached the slave 2055 */ 2056 if (!USES_PRIMARY(bond->params.mode)) { 2057 /* unset promiscuity level from slave */ 2058 if (bond_dev->flags & IFF_PROMISC) { 2059 dev_set_promiscuity(slave_dev, -1); 2060 } 2061 2062 /* unset allmulti level from slave */ 2063 if (bond_dev->flags & IFF_ALLMULTI) { 2064 dev_set_allmulti(slave_dev, -1); 2065 } 2066 2067 /* flush master's mc_list from slave */ 2068 netif_addr_lock_bh(bond_dev); 2069 bond_mc_list_flush(bond_dev, slave_dev); 2070 netif_addr_unlock_bh(bond_dev); 2071 } 2072 2073 netdev_set_master(slave_dev, NULL); 2074 2075 /* close slave before restoring its mac address */ 2076 dev_close(slave_dev); 2077 2078 if (!bond->params.fail_over_mac) { 2079 /* restore original ("permanent") mac address*/ 2080 memcpy(addr.sa_data, slave->perm_hwaddr, ETH_ALEN); 2081 addr.sa_family = slave_dev->type; 2082 dev_set_mac_address(slave_dev, &addr); 2083 } 2084 2085 slave_dev->priv_flags &= ~(IFF_MASTER_8023AD | IFF_MASTER_ALB | 2086 IFF_SLAVE_INACTIVE); 2087 2088 kfree(slave); 2089 2090 /* re-acquire the lock before getting the next slave */ 2091 write_lock_bh(&bond->lock); 2092 } 2093 2094 /* zero the mac address of the master so it will be 2095 * set by the application to the mac address of the 2096 * first slave 2097 */ 2098 memset(bond_dev->dev_addr, 0, bond_dev->addr_len); 2099 2100 if (list_empty(&bond->vlan_list)) { 2101 bond_dev->features |= NETIF_F_VLAN_CHALLENGED; 2102 } else { 2103 printk(KERN_WARNING DRV_NAME 2104 ": %s: Warning: clearing HW address of %s while it " 2105 "still has VLANs.\n", 2106 bond_dev->name, bond_dev->name); 2107 printk(KERN_WARNING DRV_NAME 2108 ": %s: When re-adding slaves, make sure the bond's " 2109 "HW address matches its VLANs'.\n", 2110 bond_dev->name); 2111 } 2112 2113 printk(KERN_INFO DRV_NAME 2114 ": %s: released all slaves\n", 2115 bond_dev->name); 2116 2117 out: 2118 write_unlock_bh(&bond->lock); 2119 2120 return 0; 2121 } 2122 2123 /* 2124 * This function changes the active slave to slave <slave_dev>. 2125 * It returns -EINVAL in the following cases. 2126 * - <slave_dev> is not found in the list. 2127 * - There is not active slave now. 2128 * - <slave_dev> is already active. 2129 * - The link state of <slave_dev> is not BOND_LINK_UP. 2130 * - <slave_dev> is not running. 2131 * In these cases, this fuction does nothing. 2132 * In the other cases, currnt_slave pointer is changed and 0 is returned. 2133 */ 2134 static int bond_ioctl_change_active(struct net_device *bond_dev, struct net_device *slave_dev) 2135 { 2136 struct bonding *bond = bond_dev->priv; 2137 struct slave *old_active = NULL; 2138 struct slave *new_active = NULL; 2139 int res = 0; 2140 2141 if (!USES_PRIMARY(bond->params.mode)) { 2142 return -EINVAL; 2143 } 2144 2145 /* Verify that master_dev is indeed the master of slave_dev */ 2146 if (!(slave_dev->flags & IFF_SLAVE) || 2147 (slave_dev->master != bond_dev)) { 2148 return -EINVAL; 2149 } 2150 2151 read_lock(&bond->lock); 2152 2153 read_lock(&bond->curr_slave_lock); 2154 old_active = bond->curr_active_slave; 2155 read_unlock(&bond->curr_slave_lock); 2156 2157 new_active = bond_get_slave_by_dev(bond, slave_dev); 2158 2159 /* 2160 * Changing to the current active: do nothing; return success. 2161 */ 2162 if (new_active && (new_active == old_active)) { 2163 read_unlock(&bond->lock); 2164 return 0; 2165 } 2166 2167 if ((new_active) && 2168 (old_active) && 2169 (new_active->link == BOND_LINK_UP) && 2170 IS_UP(new_active->dev)) { 2171 write_lock_bh(&bond->curr_slave_lock); 2172 bond_change_active_slave(bond, new_active); 2173 write_unlock_bh(&bond->curr_slave_lock); 2174 } else { 2175 res = -EINVAL; 2176 } 2177 2178 read_unlock(&bond->lock); 2179 2180 return res; 2181 } 2182 2183 static int bond_info_query(struct net_device *bond_dev, struct ifbond *info) 2184 { 2185 struct bonding *bond = bond_dev->priv; 2186 2187 info->bond_mode = bond->params.mode; 2188 info->miimon = bond->params.miimon; 2189 2190 read_lock(&bond->lock); 2191 info->num_slaves = bond->slave_cnt; 2192 read_unlock(&bond->lock); 2193 2194 return 0; 2195 } 2196 2197 static int bond_slave_info_query(struct net_device *bond_dev, struct ifslave *info) 2198 { 2199 struct bonding *bond = bond_dev->priv; 2200 struct slave *slave; 2201 int i, found = 0; 2202 2203 if (info->slave_id < 0) { 2204 return -ENODEV; 2205 } 2206 2207 read_lock(&bond->lock); 2208 2209 bond_for_each_slave(bond, slave, i) { 2210 if (i == (int)info->slave_id) { 2211 found = 1; 2212 break; 2213 } 2214 } 2215 2216 read_unlock(&bond->lock); 2217 2218 if (found) { 2219 strcpy(info->slave_name, slave->dev->name); 2220 info->link = slave->link; 2221 info->state = slave->state; 2222 info->link_failure_count = slave->link_failure_count; 2223 } else { 2224 return -ENODEV; 2225 } 2226 2227 return 0; 2228 } 2229 2230 /*-------------------------------- Monitoring -------------------------------*/ 2231 2232 2233 static int bond_miimon_inspect(struct bonding *bond) 2234 { 2235 struct slave *slave; 2236 int i, link_state, commit = 0; 2237 2238 bond_for_each_slave(bond, slave, i) { 2239 slave->new_link = BOND_LINK_NOCHANGE; 2240 2241 link_state = bond_check_dev_link(bond, slave->dev, 0); 2242 2243 switch (slave->link) { 2244 case BOND_LINK_UP: 2245 if (link_state) 2246 continue; 2247 2248 slave->link = BOND_LINK_FAIL; 2249 slave->delay = bond->params.downdelay; 2250 if (slave->delay) { 2251 printk(KERN_INFO DRV_NAME 2252 ": %s: link status down for %s" 2253 "interface %s, disabling it in %d ms.\n", 2254 bond->dev->name, 2255 (bond->params.mode == 2256 BOND_MODE_ACTIVEBACKUP) ? 2257 ((slave->state == BOND_STATE_ACTIVE) ? 2258 "active " : "backup ") : "", 2259 slave->dev->name, 2260 bond->params.downdelay * bond->params.miimon); 2261 } 2262 /*FALLTHRU*/ 2263 case BOND_LINK_FAIL: 2264 if (link_state) { 2265 /* 2266 * recovered before downdelay expired 2267 */ 2268 slave->link = BOND_LINK_UP; 2269 slave->jiffies = jiffies; 2270 printk(KERN_INFO DRV_NAME 2271 ": %s: link status up again after %d " 2272 "ms for interface %s.\n", 2273 bond->dev->name, 2274 (bond->params.downdelay - slave->delay) * 2275 bond->params.miimon, 2276 slave->dev->name); 2277 continue; 2278 } 2279 2280 if (slave->delay <= 0) { 2281 slave->new_link = BOND_LINK_DOWN; 2282 commit++; 2283 continue; 2284 } 2285 2286 slave->delay--; 2287 break; 2288 2289 case BOND_LINK_DOWN: 2290 if (!link_state) 2291 continue; 2292 2293 slave->link = BOND_LINK_BACK; 2294 slave->delay = bond->params.updelay; 2295 2296 if (slave->delay) { 2297 printk(KERN_INFO DRV_NAME 2298 ": %s: link status up for " 2299 "interface %s, enabling it in %d ms.\n", 2300 bond->dev->name, slave->dev->name, 2301 bond->params.updelay * 2302 bond->params.miimon); 2303 } 2304 /*FALLTHRU*/ 2305 case BOND_LINK_BACK: 2306 if (!link_state) { 2307 slave->link = BOND_LINK_DOWN; 2308 printk(KERN_INFO DRV_NAME 2309 ": %s: link status down again after %d " 2310 "ms for interface %s.\n", 2311 bond->dev->name, 2312 (bond->params.updelay - slave->delay) * 2313 bond->params.miimon, 2314 slave->dev->name); 2315 2316 continue; 2317 } 2318 2319 if (slave->delay <= 0) { 2320 slave->new_link = BOND_LINK_UP; 2321 commit++; 2322 continue; 2323 } 2324 2325 slave->delay--; 2326 break; 2327 } 2328 } 2329 2330 return commit; 2331 } 2332 2333 static void bond_miimon_commit(struct bonding *bond) 2334 { 2335 struct slave *slave; 2336 int i; 2337 2338 bond_for_each_slave(bond, slave, i) { 2339 switch (slave->new_link) { 2340 case BOND_LINK_NOCHANGE: 2341 continue; 2342 2343 case BOND_LINK_UP: 2344 slave->link = BOND_LINK_UP; 2345 slave->jiffies = jiffies; 2346 2347 if (bond->params.mode == BOND_MODE_8023AD) { 2348 /* prevent it from being the active one */ 2349 slave->state = BOND_STATE_BACKUP; 2350 } else if (bond->params.mode != BOND_MODE_ACTIVEBACKUP) { 2351 /* make it immediately active */ 2352 slave->state = BOND_STATE_ACTIVE; 2353 } else if (slave != bond->primary_slave) { 2354 /* prevent it from being the active one */ 2355 slave->state = BOND_STATE_BACKUP; 2356 } 2357 2358 printk(KERN_INFO DRV_NAME 2359 ": %s: link status definitely " 2360 "up for interface %s.\n", 2361 bond->dev->name, slave->dev->name); 2362 2363 /* notify ad that the link status has changed */ 2364 if (bond->params.mode == BOND_MODE_8023AD) 2365 bond_3ad_handle_link_change(slave, BOND_LINK_UP); 2366 2367 if ((bond->params.mode == BOND_MODE_TLB) || 2368 (bond->params.mode == BOND_MODE_ALB)) 2369 bond_alb_handle_link_change(bond, slave, 2370 BOND_LINK_UP); 2371 2372 if (!bond->curr_active_slave || 2373 (slave == bond->primary_slave)) 2374 goto do_failover; 2375 2376 continue; 2377 2378 case BOND_LINK_DOWN: 2379 slave->link = BOND_LINK_DOWN; 2380 2381 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP || 2382 bond->params.mode == BOND_MODE_8023AD) 2383 bond_set_slave_inactive_flags(slave); 2384 2385 printk(KERN_INFO DRV_NAME 2386 ": %s: link status definitely down for " 2387 "interface %s, disabling it\n", 2388 bond->dev->name, slave->dev->name); 2389 2390 if (bond->params.mode == BOND_MODE_8023AD) 2391 bond_3ad_handle_link_change(slave, 2392 BOND_LINK_DOWN); 2393 2394 if (bond->params.mode == BOND_MODE_TLB || 2395 bond->params.mode == BOND_MODE_ALB) 2396 bond_alb_handle_link_change(bond, slave, 2397 BOND_LINK_DOWN); 2398 2399 if (slave == bond->curr_active_slave) 2400 goto do_failover; 2401 2402 continue; 2403 2404 default: 2405 printk(KERN_ERR DRV_NAME 2406 ": %s: invalid new link %d on slave %s\n", 2407 bond->dev->name, slave->new_link, 2408 slave->dev->name); 2409 slave->new_link = BOND_LINK_NOCHANGE; 2410 2411 continue; 2412 } 2413 2414 do_failover: 2415 ASSERT_RTNL(); 2416 write_lock_bh(&bond->curr_slave_lock); 2417 bond_select_active_slave(bond); 2418 write_unlock_bh(&bond->curr_slave_lock); 2419 } 2420 2421 bond_set_carrier(bond); 2422 } 2423 2424 /* 2425 * bond_mii_monitor 2426 * 2427 * Really a wrapper that splits the mii monitor into two phases: an 2428 * inspection, then (if inspection indicates something needs to be done) 2429 * an acquisition of appropriate locks followed by a commit phase to 2430 * implement whatever link state changes are indicated. 2431 */ 2432 void bond_mii_monitor(struct work_struct *work) 2433 { 2434 struct bonding *bond = container_of(work, struct bonding, 2435 mii_work.work); 2436 2437 read_lock(&bond->lock); 2438 if (bond->kill_timers) 2439 goto out; 2440 2441 if (bond->slave_cnt == 0) 2442 goto re_arm; 2443 2444 if (bond->send_grat_arp) { 2445 read_lock(&bond->curr_slave_lock); 2446 bond_send_gratuitous_arp(bond); 2447 read_unlock(&bond->curr_slave_lock); 2448 } 2449 2450 if (bond_miimon_inspect(bond)) { 2451 read_unlock(&bond->lock); 2452 rtnl_lock(); 2453 read_lock(&bond->lock); 2454 2455 bond_miimon_commit(bond); 2456 2457 read_unlock(&bond->lock); 2458 rtnl_unlock(); /* might sleep, hold no other locks */ 2459 read_lock(&bond->lock); 2460 } 2461 2462 re_arm: 2463 if (bond->params.miimon) 2464 queue_delayed_work(bond->wq, &bond->mii_work, 2465 msecs_to_jiffies(bond->params.miimon)); 2466 out: 2467 read_unlock(&bond->lock); 2468 } 2469 2470 static __be32 bond_glean_dev_ip(struct net_device *dev) 2471 { 2472 struct in_device *idev; 2473 struct in_ifaddr *ifa; 2474 __be32 addr = 0; 2475 2476 if (!dev) 2477 return 0; 2478 2479 rcu_read_lock(); 2480 idev = __in_dev_get_rcu(dev); 2481 if (!idev) 2482 goto out; 2483 2484 ifa = idev->ifa_list; 2485 if (!ifa) 2486 goto out; 2487 2488 addr = ifa->ifa_local; 2489 out: 2490 rcu_read_unlock(); 2491 return addr; 2492 } 2493 2494 static int bond_has_this_ip(struct bonding *bond, __be32 ip) 2495 { 2496 struct vlan_entry *vlan; 2497 2498 if (ip == bond->master_ip) 2499 return 1; 2500 2501 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) { 2502 if (ip == vlan->vlan_ip) 2503 return 1; 2504 } 2505 2506 return 0; 2507 } 2508 2509 /* 2510 * We go to the (large) trouble of VLAN tagging ARP frames because 2511 * switches in VLAN mode (especially if ports are configured as 2512 * "native" to a VLAN) might not pass non-tagged frames. 2513 */ 2514 static void bond_arp_send(struct net_device *slave_dev, int arp_op, __be32 dest_ip, __be32 src_ip, unsigned short vlan_id) 2515 { 2516 struct sk_buff *skb; 2517 2518 dprintk("arp %d on slave %s: dst %x src %x vid %d\n", arp_op, 2519 slave_dev->name, dest_ip, src_ip, vlan_id); 2520 2521 skb = arp_create(arp_op, ETH_P_ARP, dest_ip, slave_dev, src_ip, 2522 NULL, slave_dev->dev_addr, NULL); 2523 2524 if (!skb) { 2525 printk(KERN_ERR DRV_NAME ": ARP packet allocation failed\n"); 2526 return; 2527 } 2528 if (vlan_id) { 2529 skb = vlan_put_tag(skb, vlan_id); 2530 if (!skb) { 2531 printk(KERN_ERR DRV_NAME ": failed to insert VLAN tag\n"); 2532 return; 2533 } 2534 } 2535 arp_xmit(skb); 2536 } 2537 2538 2539 static void bond_arp_send_all(struct bonding *bond, struct slave *slave) 2540 { 2541 int i, vlan_id, rv; 2542 __be32 *targets = bond->params.arp_targets; 2543 struct vlan_entry *vlan; 2544 struct net_device *vlan_dev; 2545 struct flowi fl; 2546 struct rtable *rt; 2547 2548 for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) { 2549 if (!targets[i]) 2550 continue; 2551 dprintk("basa: target %x\n", targets[i]); 2552 if (list_empty(&bond->vlan_list)) { 2553 dprintk("basa: empty vlan: arp_send\n"); 2554 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i], 2555 bond->master_ip, 0); 2556 continue; 2557 } 2558 2559 /* 2560 * If VLANs are configured, we do a route lookup to 2561 * determine which VLAN interface would be used, so we 2562 * can tag the ARP with the proper VLAN tag. 2563 */ 2564 memset(&fl, 0, sizeof(fl)); 2565 fl.fl4_dst = targets[i]; 2566 fl.fl4_tos = RTO_ONLINK; 2567 2568 rv = ip_route_output_key(&init_net, &rt, &fl); 2569 if (rv) { 2570 if (net_ratelimit()) { 2571 printk(KERN_WARNING DRV_NAME 2572 ": %s: no route to arp_ip_target %u.%u.%u.%u\n", 2573 bond->dev->name, NIPQUAD(fl.fl4_dst)); 2574 } 2575 continue; 2576 } 2577 2578 /* 2579 * This target is not on a VLAN 2580 */ 2581 if (rt->u.dst.dev == bond->dev) { 2582 ip_rt_put(rt); 2583 dprintk("basa: rtdev == bond->dev: arp_send\n"); 2584 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i], 2585 bond->master_ip, 0); 2586 continue; 2587 } 2588 2589 vlan_id = 0; 2590 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) { 2591 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id); 2592 if (vlan_dev == rt->u.dst.dev) { 2593 vlan_id = vlan->vlan_id; 2594 dprintk("basa: vlan match on %s %d\n", 2595 vlan_dev->name, vlan_id); 2596 break; 2597 } 2598 } 2599 2600 if (vlan_id) { 2601 ip_rt_put(rt); 2602 bond_arp_send(slave->dev, ARPOP_REQUEST, targets[i], 2603 vlan->vlan_ip, vlan_id); 2604 continue; 2605 } 2606 2607 if (net_ratelimit()) { 2608 printk(KERN_WARNING DRV_NAME 2609 ": %s: no path to arp_ip_target %u.%u.%u.%u via rt.dev %s\n", 2610 bond->dev->name, NIPQUAD(fl.fl4_dst), 2611 rt->u.dst.dev ? rt->u.dst.dev->name : "NULL"); 2612 } 2613 ip_rt_put(rt); 2614 } 2615 } 2616 2617 /* 2618 * Kick out a gratuitous ARP for an IP on the bonding master plus one 2619 * for each VLAN above us. 2620 * 2621 * Caller must hold curr_slave_lock for read or better 2622 */ 2623 static void bond_send_gratuitous_arp(struct bonding *bond) 2624 { 2625 struct slave *slave = bond->curr_active_slave; 2626 struct vlan_entry *vlan; 2627 struct net_device *vlan_dev; 2628 2629 dprintk("bond_send_grat_arp: bond %s slave %s\n", bond->dev->name, 2630 slave ? slave->dev->name : "NULL"); 2631 2632 if (!slave || !bond->send_grat_arp || 2633 test_bit(__LINK_STATE_LINKWATCH_PENDING, &slave->dev->state)) 2634 return; 2635 2636 bond->send_grat_arp--; 2637 2638 if (bond->master_ip) { 2639 bond_arp_send(slave->dev, ARPOP_REPLY, bond->master_ip, 2640 bond->master_ip, 0); 2641 } 2642 2643 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) { 2644 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id); 2645 if (vlan->vlan_ip) { 2646 bond_arp_send(slave->dev, ARPOP_REPLY, vlan->vlan_ip, 2647 vlan->vlan_ip, vlan->vlan_id); 2648 } 2649 } 2650 } 2651 2652 static void bond_validate_arp(struct bonding *bond, struct slave *slave, __be32 sip, __be32 tip) 2653 { 2654 int i; 2655 __be32 *targets = bond->params.arp_targets; 2656 2657 targets = bond->params.arp_targets; 2658 for (i = 0; (i < BOND_MAX_ARP_TARGETS) && targets[i]; i++) { 2659 dprintk("bva: sip %u.%u.%u.%u tip %u.%u.%u.%u t[%d] " 2660 "%u.%u.%u.%u bhti(tip) %d\n", 2661 NIPQUAD(sip), NIPQUAD(tip), i, NIPQUAD(targets[i]), 2662 bond_has_this_ip(bond, tip)); 2663 if (sip == targets[i]) { 2664 if (bond_has_this_ip(bond, tip)) 2665 slave->last_arp_rx = jiffies; 2666 return; 2667 } 2668 } 2669 } 2670 2671 static int bond_arp_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev) 2672 { 2673 struct arphdr *arp; 2674 struct slave *slave; 2675 struct bonding *bond; 2676 unsigned char *arp_ptr; 2677 __be32 sip, tip; 2678 2679 if (dev_net(dev) != &init_net) 2680 goto out; 2681 2682 if (!(dev->priv_flags & IFF_BONDING) || !(dev->flags & IFF_MASTER)) 2683 goto out; 2684 2685 bond = dev->priv; 2686 read_lock(&bond->lock); 2687 2688 dprintk("bond_arp_rcv: bond %s skb->dev %s orig_dev %s\n", 2689 bond->dev->name, skb->dev ? skb->dev->name : "NULL", 2690 orig_dev ? orig_dev->name : "NULL"); 2691 2692 slave = bond_get_slave_by_dev(bond, orig_dev); 2693 if (!slave || !slave_do_arp_validate(bond, slave)) 2694 goto out_unlock; 2695 2696 if (!pskb_may_pull(skb, arp_hdr_len(dev))) 2697 goto out_unlock; 2698 2699 arp = arp_hdr(skb); 2700 if (arp->ar_hln != dev->addr_len || 2701 skb->pkt_type == PACKET_OTHERHOST || 2702 skb->pkt_type == PACKET_LOOPBACK || 2703 arp->ar_hrd != htons(ARPHRD_ETHER) || 2704 arp->ar_pro != htons(ETH_P_IP) || 2705 arp->ar_pln != 4) 2706 goto out_unlock; 2707 2708 arp_ptr = (unsigned char *)(arp + 1); 2709 arp_ptr += dev->addr_len; 2710 memcpy(&sip, arp_ptr, 4); 2711 arp_ptr += 4 + dev->addr_len; 2712 memcpy(&tip, arp_ptr, 4); 2713 2714 dprintk("bond_arp_rcv: %s %s/%d av %d sv %d sip %u.%u.%u.%u" 2715 " tip %u.%u.%u.%u\n", bond->dev->name, slave->dev->name, 2716 slave->state, bond->params.arp_validate, 2717 slave_do_arp_validate(bond, slave), NIPQUAD(sip), NIPQUAD(tip)); 2718 2719 /* 2720 * Backup slaves won't see the ARP reply, but do come through 2721 * here for each ARP probe (so we swap the sip/tip to validate 2722 * the probe). In a "redundant switch, common router" type of 2723 * configuration, the ARP probe will (hopefully) travel from 2724 * the active, through one switch, the router, then the other 2725 * switch before reaching the backup. 2726 */ 2727 if (slave->state == BOND_STATE_ACTIVE) 2728 bond_validate_arp(bond, slave, sip, tip); 2729 else 2730 bond_validate_arp(bond, slave, tip, sip); 2731 2732 out_unlock: 2733 read_unlock(&bond->lock); 2734 out: 2735 dev_kfree_skb(skb); 2736 return NET_RX_SUCCESS; 2737 } 2738 2739 /* 2740 * this function is called regularly to monitor each slave's link 2741 * ensuring that traffic is being sent and received when arp monitoring 2742 * is used in load-balancing mode. if the adapter has been dormant, then an 2743 * arp is transmitted to generate traffic. see activebackup_arp_monitor for 2744 * arp monitoring in active backup mode. 2745 */ 2746 void bond_loadbalance_arp_mon(struct work_struct *work) 2747 { 2748 struct bonding *bond = container_of(work, struct bonding, 2749 arp_work.work); 2750 struct slave *slave, *oldcurrent; 2751 int do_failover = 0; 2752 int delta_in_ticks; 2753 int i; 2754 2755 read_lock(&bond->lock); 2756 2757 delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval); 2758 2759 if (bond->kill_timers) { 2760 goto out; 2761 } 2762 2763 if (bond->slave_cnt == 0) { 2764 goto re_arm; 2765 } 2766 2767 read_lock(&bond->curr_slave_lock); 2768 oldcurrent = bond->curr_active_slave; 2769 read_unlock(&bond->curr_slave_lock); 2770 2771 /* see if any of the previous devices are up now (i.e. they have 2772 * xmt and rcv traffic). the curr_active_slave does not come into 2773 * the picture unless it is null. also, slave->jiffies is not needed 2774 * here because we send an arp on each slave and give a slave as 2775 * long as it needs to get the tx/rx within the delta. 2776 * TODO: what about up/down delay in arp mode? it wasn't here before 2777 * so it can wait 2778 */ 2779 bond_for_each_slave(bond, slave, i) { 2780 if (slave->link != BOND_LINK_UP) { 2781 if (time_before_eq(jiffies, slave->dev->trans_start + delta_in_ticks) && 2782 time_before_eq(jiffies, slave->dev->last_rx + delta_in_ticks)) { 2783 2784 slave->link = BOND_LINK_UP; 2785 slave->state = BOND_STATE_ACTIVE; 2786 2787 /* primary_slave has no meaning in round-robin 2788 * mode. the window of a slave being up and 2789 * curr_active_slave being null after enslaving 2790 * is closed. 2791 */ 2792 if (!oldcurrent) { 2793 printk(KERN_INFO DRV_NAME 2794 ": %s: link status definitely " 2795 "up for interface %s, ", 2796 bond->dev->name, 2797 slave->dev->name); 2798 do_failover = 1; 2799 } else { 2800 printk(KERN_INFO DRV_NAME 2801 ": %s: interface %s is now up\n", 2802 bond->dev->name, 2803 slave->dev->name); 2804 } 2805 } 2806 } else { 2807 /* slave->link == BOND_LINK_UP */ 2808 2809 /* not all switches will respond to an arp request 2810 * when the source ip is 0, so don't take the link down 2811 * if we don't know our ip yet 2812 */ 2813 if (time_after_eq(jiffies, slave->dev->trans_start + 2*delta_in_ticks) || 2814 (time_after_eq(jiffies, slave->dev->last_rx + 2*delta_in_ticks))) { 2815 2816 slave->link = BOND_LINK_DOWN; 2817 slave->state = BOND_STATE_BACKUP; 2818 2819 if (slave->link_failure_count < UINT_MAX) { 2820 slave->link_failure_count++; 2821 } 2822 2823 printk(KERN_INFO DRV_NAME 2824 ": %s: interface %s is now down.\n", 2825 bond->dev->name, 2826 slave->dev->name); 2827 2828 if (slave == oldcurrent) { 2829 do_failover = 1; 2830 } 2831 } 2832 } 2833 2834 /* note: if switch is in round-robin mode, all links 2835 * must tx arp to ensure all links rx an arp - otherwise 2836 * links may oscillate or not come up at all; if switch is 2837 * in something like xor mode, there is nothing we can 2838 * do - all replies will be rx'ed on same link causing slaves 2839 * to be unstable during low/no traffic periods 2840 */ 2841 if (IS_UP(slave->dev)) { 2842 bond_arp_send_all(bond, slave); 2843 } 2844 } 2845 2846 if (do_failover) { 2847 write_lock_bh(&bond->curr_slave_lock); 2848 2849 bond_select_active_slave(bond); 2850 2851 write_unlock_bh(&bond->curr_slave_lock); 2852 } 2853 2854 re_arm: 2855 if (bond->params.arp_interval) 2856 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks); 2857 out: 2858 read_unlock(&bond->lock); 2859 } 2860 2861 /* 2862 * Called to inspect slaves for active-backup mode ARP monitor link state 2863 * changes. Sets new_link in slaves to specify what action should take 2864 * place for the slave. Returns 0 if no changes are found, >0 if changes 2865 * to link states must be committed. 2866 * 2867 * Called with bond->lock held for read. 2868 */ 2869 static int bond_ab_arp_inspect(struct bonding *bond, int delta_in_ticks) 2870 { 2871 struct slave *slave; 2872 int i, commit = 0; 2873 2874 bond_for_each_slave(bond, slave, i) { 2875 slave->new_link = BOND_LINK_NOCHANGE; 2876 2877 if (slave->link != BOND_LINK_UP) { 2878 if (time_before_eq(jiffies, slave_last_rx(bond, slave) + 2879 delta_in_ticks)) { 2880 slave->new_link = BOND_LINK_UP; 2881 commit++; 2882 } 2883 2884 continue; 2885 } 2886 2887 /* 2888 * Give slaves 2*delta after being enslaved or made 2889 * active. This avoids bouncing, as the last receive 2890 * times need a full ARP monitor cycle to be updated. 2891 */ 2892 if (!time_after_eq(jiffies, slave->jiffies + 2893 2 * delta_in_ticks)) 2894 continue; 2895 2896 /* 2897 * Backup slave is down if: 2898 * - No current_arp_slave AND 2899 * - more than 3*delta since last receive AND 2900 * - the bond has an IP address 2901 * 2902 * Note: a non-null current_arp_slave indicates 2903 * the curr_active_slave went down and we are 2904 * searching for a new one; under this condition 2905 * we only take the curr_active_slave down - this 2906 * gives each slave a chance to tx/rx traffic 2907 * before being taken out 2908 */ 2909 if (slave->state == BOND_STATE_BACKUP && 2910 !bond->current_arp_slave && 2911 time_after(jiffies, slave_last_rx(bond, slave) + 2912 3 * delta_in_ticks)) { 2913 slave->new_link = BOND_LINK_DOWN; 2914 commit++; 2915 } 2916 2917 /* 2918 * Active slave is down if: 2919 * - more than 2*delta since transmitting OR 2920 * - (more than 2*delta since receive AND 2921 * the bond has an IP address) 2922 */ 2923 if ((slave->state == BOND_STATE_ACTIVE) && 2924 (time_after_eq(jiffies, slave->dev->trans_start + 2925 2 * delta_in_ticks) || 2926 (time_after_eq(jiffies, slave_last_rx(bond, slave) 2927 + 2 * delta_in_ticks)))) { 2928 slave->new_link = BOND_LINK_DOWN; 2929 commit++; 2930 } 2931 } 2932 2933 read_lock(&bond->curr_slave_lock); 2934 2935 /* 2936 * Trigger a commit if the primary option setting has changed. 2937 */ 2938 if (bond->primary_slave && 2939 (bond->primary_slave != bond->curr_active_slave) && 2940 (bond->primary_slave->link == BOND_LINK_UP)) 2941 commit++; 2942 2943 read_unlock(&bond->curr_slave_lock); 2944 2945 return commit; 2946 } 2947 2948 /* 2949 * Called to commit link state changes noted by inspection step of 2950 * active-backup mode ARP monitor. 2951 * 2952 * Called with RTNL and bond->lock for read. 2953 */ 2954 static void bond_ab_arp_commit(struct bonding *bond, int delta_in_ticks) 2955 { 2956 struct slave *slave; 2957 int i; 2958 2959 bond_for_each_slave(bond, slave, i) { 2960 switch (slave->new_link) { 2961 case BOND_LINK_NOCHANGE: 2962 continue; 2963 2964 case BOND_LINK_UP: 2965 write_lock_bh(&bond->curr_slave_lock); 2966 2967 if (!bond->curr_active_slave && 2968 time_before_eq(jiffies, slave->dev->trans_start + 2969 delta_in_ticks)) { 2970 slave->link = BOND_LINK_UP; 2971 bond_change_active_slave(bond, slave); 2972 bond->current_arp_slave = NULL; 2973 2974 printk(KERN_INFO DRV_NAME 2975 ": %s: %s is up and now the " 2976 "active interface\n", 2977 bond->dev->name, slave->dev->name); 2978 2979 } else if (bond->curr_active_slave != slave) { 2980 /* this slave has just come up but we 2981 * already have a current slave; this can 2982 * also happen if bond_enslave adds a new 2983 * slave that is up while we are searching 2984 * for a new slave 2985 */ 2986 slave->link = BOND_LINK_UP; 2987 bond_set_slave_inactive_flags(slave); 2988 bond->current_arp_slave = NULL; 2989 2990 printk(KERN_INFO DRV_NAME 2991 ": %s: backup interface %s is now up\n", 2992 bond->dev->name, slave->dev->name); 2993 } 2994 2995 write_unlock_bh(&bond->curr_slave_lock); 2996 2997 break; 2998 2999 case BOND_LINK_DOWN: 3000 if (slave->link_failure_count < UINT_MAX) 3001 slave->link_failure_count++; 3002 3003 slave->link = BOND_LINK_DOWN; 3004 3005 if (slave == bond->curr_active_slave) { 3006 printk(KERN_INFO DRV_NAME 3007 ": %s: link status down for active " 3008 "interface %s, disabling it\n", 3009 bond->dev->name, slave->dev->name); 3010 3011 bond_set_slave_inactive_flags(slave); 3012 3013 write_lock_bh(&bond->curr_slave_lock); 3014 3015 bond_select_active_slave(bond); 3016 if (bond->curr_active_slave) 3017 bond->curr_active_slave->jiffies = 3018 jiffies; 3019 3020 write_unlock_bh(&bond->curr_slave_lock); 3021 3022 bond->current_arp_slave = NULL; 3023 3024 } else if (slave->state == BOND_STATE_BACKUP) { 3025 printk(KERN_INFO DRV_NAME 3026 ": %s: backup interface %s is now down\n", 3027 bond->dev->name, slave->dev->name); 3028 3029 bond_set_slave_inactive_flags(slave); 3030 } 3031 break; 3032 3033 default: 3034 printk(KERN_ERR DRV_NAME 3035 ": %s: impossible: new_link %d on slave %s\n", 3036 bond->dev->name, slave->new_link, 3037 slave->dev->name); 3038 } 3039 } 3040 3041 /* 3042 * No race with changes to primary via sysfs, as we hold rtnl. 3043 */ 3044 if (bond->primary_slave && 3045 (bond->primary_slave != bond->curr_active_slave) && 3046 (bond->primary_slave->link == BOND_LINK_UP)) { 3047 write_lock_bh(&bond->curr_slave_lock); 3048 bond_change_active_slave(bond, bond->primary_slave); 3049 write_unlock_bh(&bond->curr_slave_lock); 3050 } 3051 3052 bond_set_carrier(bond); 3053 } 3054 3055 /* 3056 * Send ARP probes for active-backup mode ARP monitor. 3057 * 3058 * Called with bond->lock held for read. 3059 */ 3060 static void bond_ab_arp_probe(struct bonding *bond) 3061 { 3062 struct slave *slave; 3063 int i; 3064 3065 read_lock(&bond->curr_slave_lock); 3066 3067 if (bond->current_arp_slave && bond->curr_active_slave) 3068 printk("PROBE: c_arp %s && cas %s BAD\n", 3069 bond->current_arp_slave->dev->name, 3070 bond->curr_active_slave->dev->name); 3071 3072 if (bond->curr_active_slave) { 3073 bond_arp_send_all(bond, bond->curr_active_slave); 3074 read_unlock(&bond->curr_slave_lock); 3075 return; 3076 } 3077 3078 read_unlock(&bond->curr_slave_lock); 3079 3080 /* if we don't have a curr_active_slave, search for the next available 3081 * backup slave from the current_arp_slave and make it the candidate 3082 * for becoming the curr_active_slave 3083 */ 3084 3085 if (!bond->current_arp_slave) { 3086 bond->current_arp_slave = bond->first_slave; 3087 if (!bond->current_arp_slave) 3088 return; 3089 } 3090 3091 bond_set_slave_inactive_flags(bond->current_arp_slave); 3092 3093 /* search for next candidate */ 3094 bond_for_each_slave_from(bond, slave, i, bond->current_arp_slave->next) { 3095 if (IS_UP(slave->dev)) { 3096 slave->link = BOND_LINK_BACK; 3097 bond_set_slave_active_flags(slave); 3098 bond_arp_send_all(bond, slave); 3099 slave->jiffies = jiffies; 3100 bond->current_arp_slave = slave; 3101 break; 3102 } 3103 3104 /* if the link state is up at this point, we 3105 * mark it down - this can happen if we have 3106 * simultaneous link failures and 3107 * reselect_active_interface doesn't make this 3108 * one the current slave so it is still marked 3109 * up when it is actually down 3110 */ 3111 if (slave->link == BOND_LINK_UP) { 3112 slave->link = BOND_LINK_DOWN; 3113 if (slave->link_failure_count < UINT_MAX) 3114 slave->link_failure_count++; 3115 3116 bond_set_slave_inactive_flags(slave); 3117 3118 printk(KERN_INFO DRV_NAME 3119 ": %s: backup interface %s is now down.\n", 3120 bond->dev->name, slave->dev->name); 3121 } 3122 } 3123 } 3124 3125 void bond_activebackup_arp_mon(struct work_struct *work) 3126 { 3127 struct bonding *bond = container_of(work, struct bonding, 3128 arp_work.work); 3129 int delta_in_ticks; 3130 3131 read_lock(&bond->lock); 3132 3133 if (bond->kill_timers) 3134 goto out; 3135 3136 delta_in_ticks = msecs_to_jiffies(bond->params.arp_interval); 3137 3138 if (bond->slave_cnt == 0) 3139 goto re_arm; 3140 3141 if (bond->send_grat_arp) { 3142 read_lock(&bond->curr_slave_lock); 3143 bond_send_gratuitous_arp(bond); 3144 read_unlock(&bond->curr_slave_lock); 3145 } 3146 3147 if (bond_ab_arp_inspect(bond, delta_in_ticks)) { 3148 read_unlock(&bond->lock); 3149 rtnl_lock(); 3150 read_lock(&bond->lock); 3151 3152 bond_ab_arp_commit(bond, delta_in_ticks); 3153 3154 read_unlock(&bond->lock); 3155 rtnl_unlock(); 3156 read_lock(&bond->lock); 3157 } 3158 3159 bond_ab_arp_probe(bond); 3160 3161 re_arm: 3162 if (bond->params.arp_interval) { 3163 queue_delayed_work(bond->wq, &bond->arp_work, delta_in_ticks); 3164 } 3165 out: 3166 read_unlock(&bond->lock); 3167 } 3168 3169 /*------------------------------ proc/seq_file-------------------------------*/ 3170 3171 #ifdef CONFIG_PROC_FS 3172 3173 static void *bond_info_seq_start(struct seq_file *seq, loff_t *pos) 3174 { 3175 struct bonding *bond = seq->private; 3176 loff_t off = 0; 3177 struct slave *slave; 3178 int i; 3179 3180 /* make sure the bond won't be taken away */ 3181 read_lock(&dev_base_lock); 3182 read_lock(&bond->lock); 3183 3184 if (*pos == 0) { 3185 return SEQ_START_TOKEN; 3186 } 3187 3188 bond_for_each_slave(bond, slave, i) { 3189 if (++off == *pos) { 3190 return slave; 3191 } 3192 } 3193 3194 return NULL; 3195 } 3196 3197 static void *bond_info_seq_next(struct seq_file *seq, void *v, loff_t *pos) 3198 { 3199 struct bonding *bond = seq->private; 3200 struct slave *slave = v; 3201 3202 ++*pos; 3203 if (v == SEQ_START_TOKEN) { 3204 return bond->first_slave; 3205 } 3206 3207 slave = slave->next; 3208 3209 return (slave == bond->first_slave) ? NULL : slave; 3210 } 3211 3212 static void bond_info_seq_stop(struct seq_file *seq, void *v) 3213 { 3214 struct bonding *bond = seq->private; 3215 3216 read_unlock(&bond->lock); 3217 read_unlock(&dev_base_lock); 3218 } 3219 3220 static void bond_info_show_master(struct seq_file *seq) 3221 { 3222 struct bonding *bond = seq->private; 3223 struct slave *curr; 3224 int i; 3225 u32 target; 3226 3227 read_lock(&bond->curr_slave_lock); 3228 curr = bond->curr_active_slave; 3229 read_unlock(&bond->curr_slave_lock); 3230 3231 seq_printf(seq, "Bonding Mode: %s", 3232 bond_mode_name(bond->params.mode)); 3233 3234 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP && 3235 bond->params.fail_over_mac) 3236 seq_printf(seq, " (fail_over_mac %s)", 3237 fail_over_mac_tbl[bond->params.fail_over_mac].modename); 3238 3239 seq_printf(seq, "\n"); 3240 3241 if (bond->params.mode == BOND_MODE_XOR || 3242 bond->params.mode == BOND_MODE_8023AD) { 3243 seq_printf(seq, "Transmit Hash Policy: %s (%d)\n", 3244 xmit_hashtype_tbl[bond->params.xmit_policy].modename, 3245 bond->params.xmit_policy); 3246 } 3247 3248 if (USES_PRIMARY(bond->params.mode)) { 3249 seq_printf(seq, "Primary Slave: %s\n", 3250 (bond->primary_slave) ? 3251 bond->primary_slave->dev->name : "None"); 3252 3253 seq_printf(seq, "Currently Active Slave: %s\n", 3254 (curr) ? curr->dev->name : "None"); 3255 } 3256 3257 seq_printf(seq, "MII Status: %s\n", netif_carrier_ok(bond->dev) ? 3258 "up" : "down"); 3259 seq_printf(seq, "MII Polling Interval (ms): %d\n", bond->params.miimon); 3260 seq_printf(seq, "Up Delay (ms): %d\n", 3261 bond->params.updelay * bond->params.miimon); 3262 seq_printf(seq, "Down Delay (ms): %d\n", 3263 bond->params.downdelay * bond->params.miimon); 3264 3265 3266 /* ARP information */ 3267 if(bond->params.arp_interval > 0) { 3268 int printed=0; 3269 seq_printf(seq, "ARP Polling Interval (ms): %d\n", 3270 bond->params.arp_interval); 3271 3272 seq_printf(seq, "ARP IP target/s (n.n.n.n form):"); 3273 3274 for(i = 0; (i < BOND_MAX_ARP_TARGETS) ;i++) { 3275 if (!bond->params.arp_targets[i]) 3276 continue; 3277 if (printed) 3278 seq_printf(seq, ","); 3279 target = ntohl(bond->params.arp_targets[i]); 3280 seq_printf(seq, " %d.%d.%d.%d", HIPQUAD(target)); 3281 printed = 1; 3282 } 3283 seq_printf(seq, "\n"); 3284 } 3285 3286 if (bond->params.mode == BOND_MODE_8023AD) { 3287 struct ad_info ad_info; 3288 DECLARE_MAC_BUF(mac); 3289 3290 seq_puts(seq, "\n802.3ad info\n"); 3291 seq_printf(seq, "LACP rate: %s\n", 3292 (bond->params.lacp_fast) ? "fast" : "slow"); 3293 3294 if (bond_3ad_get_active_agg_info(bond, &ad_info)) { 3295 seq_printf(seq, "bond %s has no active aggregator\n", 3296 bond->dev->name); 3297 } else { 3298 seq_printf(seq, "Active Aggregator Info:\n"); 3299 3300 seq_printf(seq, "\tAggregator ID: %d\n", 3301 ad_info.aggregator_id); 3302 seq_printf(seq, "\tNumber of ports: %d\n", 3303 ad_info.ports); 3304 seq_printf(seq, "\tActor Key: %d\n", 3305 ad_info.actor_key); 3306 seq_printf(seq, "\tPartner Key: %d\n", 3307 ad_info.partner_key); 3308 seq_printf(seq, "\tPartner Mac Address: %s\n", 3309 print_mac(mac, ad_info.partner_system)); 3310 } 3311 } 3312 } 3313 3314 static void bond_info_show_slave(struct seq_file *seq, const struct slave *slave) 3315 { 3316 struct bonding *bond = seq->private; 3317 DECLARE_MAC_BUF(mac); 3318 3319 seq_printf(seq, "\nSlave Interface: %s\n", slave->dev->name); 3320 seq_printf(seq, "MII Status: %s\n", 3321 (slave->link == BOND_LINK_UP) ? "up" : "down"); 3322 seq_printf(seq, "Link Failure Count: %u\n", 3323 slave->link_failure_count); 3324 3325 seq_printf(seq, 3326 "Permanent HW addr: %s\n", 3327 print_mac(mac, slave->perm_hwaddr)); 3328 3329 if (bond->params.mode == BOND_MODE_8023AD) { 3330 const struct aggregator *agg 3331 = SLAVE_AD_INFO(slave).port.aggregator; 3332 3333 if (agg) { 3334 seq_printf(seq, "Aggregator ID: %d\n", 3335 agg->aggregator_identifier); 3336 } else { 3337 seq_puts(seq, "Aggregator ID: N/A\n"); 3338 } 3339 } 3340 } 3341 3342 static int bond_info_seq_show(struct seq_file *seq, void *v) 3343 { 3344 if (v == SEQ_START_TOKEN) { 3345 seq_printf(seq, "%s\n", version); 3346 bond_info_show_master(seq); 3347 } else { 3348 bond_info_show_slave(seq, v); 3349 } 3350 3351 return 0; 3352 } 3353 3354 static struct seq_operations bond_info_seq_ops = { 3355 .start = bond_info_seq_start, 3356 .next = bond_info_seq_next, 3357 .stop = bond_info_seq_stop, 3358 .show = bond_info_seq_show, 3359 }; 3360 3361 static int bond_info_open(struct inode *inode, struct file *file) 3362 { 3363 struct seq_file *seq; 3364 struct proc_dir_entry *proc; 3365 int res; 3366 3367 res = seq_open(file, &bond_info_seq_ops); 3368 if (!res) { 3369 /* recover the pointer buried in proc_dir_entry data */ 3370 seq = file->private_data; 3371 proc = PDE(inode); 3372 seq->private = proc->data; 3373 } 3374 3375 return res; 3376 } 3377 3378 static const struct file_operations bond_info_fops = { 3379 .owner = THIS_MODULE, 3380 .open = bond_info_open, 3381 .read = seq_read, 3382 .llseek = seq_lseek, 3383 .release = seq_release, 3384 }; 3385 3386 static int bond_create_proc_entry(struct bonding *bond) 3387 { 3388 struct net_device *bond_dev = bond->dev; 3389 3390 if (bond_proc_dir) { 3391 bond->proc_entry = proc_create_data(bond_dev->name, 3392 S_IRUGO, bond_proc_dir, 3393 &bond_info_fops, bond); 3394 if (bond->proc_entry == NULL) { 3395 printk(KERN_WARNING DRV_NAME 3396 ": Warning: Cannot create /proc/net/%s/%s\n", 3397 DRV_NAME, bond_dev->name); 3398 } else { 3399 memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ); 3400 } 3401 } 3402 3403 return 0; 3404 } 3405 3406 static void bond_remove_proc_entry(struct bonding *bond) 3407 { 3408 if (bond_proc_dir && bond->proc_entry) { 3409 remove_proc_entry(bond->proc_file_name, bond_proc_dir); 3410 memset(bond->proc_file_name, 0, IFNAMSIZ); 3411 bond->proc_entry = NULL; 3412 } 3413 } 3414 3415 /* Create the bonding directory under /proc/net, if doesn't exist yet. 3416 * Caller must hold rtnl_lock. 3417 */ 3418 static void bond_create_proc_dir(void) 3419 { 3420 int len = strlen(DRV_NAME); 3421 3422 for (bond_proc_dir = init_net.proc_net->subdir; bond_proc_dir; 3423 bond_proc_dir = bond_proc_dir->next) { 3424 if ((bond_proc_dir->namelen == len) && 3425 !memcmp(bond_proc_dir->name, DRV_NAME, len)) { 3426 break; 3427 } 3428 } 3429 3430 if (!bond_proc_dir) { 3431 bond_proc_dir = proc_mkdir(DRV_NAME, init_net.proc_net); 3432 if (bond_proc_dir) { 3433 bond_proc_dir->owner = THIS_MODULE; 3434 } else { 3435 printk(KERN_WARNING DRV_NAME 3436 ": Warning: cannot create /proc/net/%s\n", 3437 DRV_NAME); 3438 } 3439 } 3440 } 3441 3442 /* Destroy the bonding directory under /proc/net, if empty. 3443 * Caller must hold rtnl_lock. 3444 */ 3445 static void bond_destroy_proc_dir(void) 3446 { 3447 struct proc_dir_entry *de; 3448 3449 if (!bond_proc_dir) { 3450 return; 3451 } 3452 3453 /* verify that the /proc dir is empty */ 3454 for (de = bond_proc_dir->subdir; de; de = de->next) { 3455 /* ignore . and .. */ 3456 if (*(de->name) != '.') { 3457 break; 3458 } 3459 } 3460 3461 if (de) { 3462 if (bond_proc_dir->owner == THIS_MODULE) { 3463 bond_proc_dir->owner = NULL; 3464 } 3465 } else { 3466 remove_proc_entry(DRV_NAME, init_net.proc_net); 3467 bond_proc_dir = NULL; 3468 } 3469 } 3470 #endif /* CONFIG_PROC_FS */ 3471 3472 /*-------------------------- netdev event handling --------------------------*/ 3473 3474 /* 3475 * Change device name 3476 */ 3477 static int bond_event_changename(struct bonding *bond) 3478 { 3479 #ifdef CONFIG_PROC_FS 3480 bond_remove_proc_entry(bond); 3481 bond_create_proc_entry(bond); 3482 #endif 3483 down_write(&(bonding_rwsem)); 3484 bond_destroy_sysfs_entry(bond); 3485 bond_create_sysfs_entry(bond); 3486 up_write(&(bonding_rwsem)); 3487 return NOTIFY_DONE; 3488 } 3489 3490 static int bond_master_netdev_event(unsigned long event, struct net_device *bond_dev) 3491 { 3492 struct bonding *event_bond = bond_dev->priv; 3493 3494 switch (event) { 3495 case NETDEV_CHANGENAME: 3496 return bond_event_changename(event_bond); 3497 case NETDEV_UNREGISTER: 3498 bond_release_all(event_bond->dev); 3499 break; 3500 default: 3501 break; 3502 } 3503 3504 return NOTIFY_DONE; 3505 } 3506 3507 static int bond_slave_netdev_event(unsigned long event, struct net_device *slave_dev) 3508 { 3509 struct net_device *bond_dev = slave_dev->master; 3510 struct bonding *bond = bond_dev->priv; 3511 3512 switch (event) { 3513 case NETDEV_UNREGISTER: 3514 if (bond_dev) { 3515 if (bond->setup_by_slave) 3516 bond_release_and_destroy(bond_dev, slave_dev); 3517 else 3518 bond_release(bond_dev, slave_dev); 3519 } 3520 break; 3521 case NETDEV_CHANGE: 3522 /* 3523 * TODO: is this what we get if somebody 3524 * sets up a hierarchical bond, then rmmod's 3525 * one of the slave bonding devices? 3526 */ 3527 break; 3528 case NETDEV_DOWN: 3529 /* 3530 * ... Or is it this? 3531 */ 3532 break; 3533 case NETDEV_CHANGEMTU: 3534 /* 3535 * TODO: Should slaves be allowed to 3536 * independently alter their MTU? For 3537 * an active-backup bond, slaves need 3538 * not be the same type of device, so 3539 * MTUs may vary. For other modes, 3540 * slaves arguably should have the 3541 * same MTUs. To do this, we'd need to 3542 * take over the slave's change_mtu 3543 * function for the duration of their 3544 * servitude. 3545 */ 3546 break; 3547 case NETDEV_CHANGENAME: 3548 /* 3549 * TODO: handle changing the primary's name 3550 */ 3551 break; 3552 case NETDEV_FEAT_CHANGE: 3553 bond_compute_features(bond); 3554 break; 3555 default: 3556 break; 3557 } 3558 3559 return NOTIFY_DONE; 3560 } 3561 3562 /* 3563 * bond_netdev_event: handle netdev notifier chain events. 3564 * 3565 * This function receives events for the netdev chain. The caller (an 3566 * ioctl handler calling blocking_notifier_call_chain) holds the necessary 3567 * locks for us to safely manipulate the slave devices (RTNL lock, 3568 * dev_probe_lock). 3569 */ 3570 static int bond_netdev_event(struct notifier_block *this, unsigned long event, void *ptr) 3571 { 3572 struct net_device *event_dev = (struct net_device *)ptr; 3573 3574 if (dev_net(event_dev) != &init_net) 3575 return NOTIFY_DONE; 3576 3577 dprintk("event_dev: %s, event: %lx\n", 3578 (event_dev ? event_dev->name : "None"), 3579 event); 3580 3581 if (!(event_dev->priv_flags & IFF_BONDING)) 3582 return NOTIFY_DONE; 3583 3584 if (event_dev->flags & IFF_MASTER) { 3585 dprintk("IFF_MASTER\n"); 3586 return bond_master_netdev_event(event, event_dev); 3587 } 3588 3589 if (event_dev->flags & IFF_SLAVE) { 3590 dprintk("IFF_SLAVE\n"); 3591 return bond_slave_netdev_event(event, event_dev); 3592 } 3593 3594 return NOTIFY_DONE; 3595 } 3596 3597 /* 3598 * bond_inetaddr_event: handle inetaddr notifier chain events. 3599 * 3600 * We keep track of device IPs primarily to use as source addresses in 3601 * ARP monitor probes (rather than spewing out broadcasts all the time). 3602 * 3603 * We track one IP for the main device (if it has one), plus one per VLAN. 3604 */ 3605 static int bond_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr) 3606 { 3607 struct in_ifaddr *ifa = ptr; 3608 struct net_device *vlan_dev, *event_dev = ifa->ifa_dev->dev; 3609 struct bonding *bond; 3610 struct vlan_entry *vlan; 3611 3612 if (dev_net(ifa->ifa_dev->dev) != &init_net) 3613 return NOTIFY_DONE; 3614 3615 list_for_each_entry(bond, &bond_dev_list, bond_list) { 3616 if (bond->dev == event_dev) { 3617 switch (event) { 3618 case NETDEV_UP: 3619 bond->master_ip = ifa->ifa_local; 3620 return NOTIFY_OK; 3621 case NETDEV_DOWN: 3622 bond->master_ip = bond_glean_dev_ip(bond->dev); 3623 return NOTIFY_OK; 3624 default: 3625 return NOTIFY_DONE; 3626 } 3627 } 3628 3629 list_for_each_entry(vlan, &bond->vlan_list, vlan_list) { 3630 vlan_dev = vlan_group_get_device(bond->vlgrp, vlan->vlan_id); 3631 if (vlan_dev == event_dev) { 3632 switch (event) { 3633 case NETDEV_UP: 3634 vlan->vlan_ip = ifa->ifa_local; 3635 return NOTIFY_OK; 3636 case NETDEV_DOWN: 3637 vlan->vlan_ip = 3638 bond_glean_dev_ip(vlan_dev); 3639 return NOTIFY_OK; 3640 default: 3641 return NOTIFY_DONE; 3642 } 3643 } 3644 } 3645 } 3646 return NOTIFY_DONE; 3647 } 3648 3649 static struct notifier_block bond_netdev_notifier = { 3650 .notifier_call = bond_netdev_event, 3651 }; 3652 3653 static struct notifier_block bond_inetaddr_notifier = { 3654 .notifier_call = bond_inetaddr_event, 3655 }; 3656 3657 /*-------------------------- Packet type handling ---------------------------*/ 3658 3659 /* register to receive lacpdus on a bond */ 3660 static void bond_register_lacpdu(struct bonding *bond) 3661 { 3662 struct packet_type *pk_type = &(BOND_AD_INFO(bond).ad_pkt_type); 3663 3664 /* initialize packet type */ 3665 pk_type->type = PKT_TYPE_LACPDU; 3666 pk_type->dev = bond->dev; 3667 pk_type->func = bond_3ad_lacpdu_recv; 3668 3669 dev_add_pack(pk_type); 3670 } 3671 3672 /* unregister to receive lacpdus on a bond */ 3673 static void bond_unregister_lacpdu(struct bonding *bond) 3674 { 3675 dev_remove_pack(&(BOND_AD_INFO(bond).ad_pkt_type)); 3676 } 3677 3678 void bond_register_arp(struct bonding *bond) 3679 { 3680 struct packet_type *pt = &bond->arp_mon_pt; 3681 3682 if (pt->type) 3683 return; 3684 3685 pt->type = htons(ETH_P_ARP); 3686 pt->dev = bond->dev; 3687 pt->func = bond_arp_rcv; 3688 dev_add_pack(pt); 3689 } 3690 3691 void bond_unregister_arp(struct bonding *bond) 3692 { 3693 struct packet_type *pt = &bond->arp_mon_pt; 3694 3695 dev_remove_pack(pt); 3696 pt->type = 0; 3697 } 3698 3699 /*---------------------------- Hashing Policies -----------------------------*/ 3700 3701 /* 3702 * Hash for the output device based upon layer 2 and layer 3 data. If 3703 * the packet is not IP mimic bond_xmit_hash_policy_l2() 3704 */ 3705 static int bond_xmit_hash_policy_l23(struct sk_buff *skb, 3706 struct net_device *bond_dev, int count) 3707 { 3708 struct ethhdr *data = (struct ethhdr *)skb->data; 3709 struct iphdr *iph = ip_hdr(skb); 3710 3711 if (skb->protocol == htons(ETH_P_IP)) { 3712 return ((ntohl(iph->saddr ^ iph->daddr) & 0xffff) ^ 3713 (data->h_dest[5] ^ bond_dev->dev_addr[5])) % count; 3714 } 3715 3716 return (data->h_dest[5] ^ bond_dev->dev_addr[5]) % count; 3717 } 3718 3719 /* 3720 * Hash for the output device based upon layer 3 and layer 4 data. If 3721 * the packet is a frag or not TCP or UDP, just use layer 3 data. If it is 3722 * altogether not IP, mimic bond_xmit_hash_policy_l2() 3723 */ 3724 static int bond_xmit_hash_policy_l34(struct sk_buff *skb, 3725 struct net_device *bond_dev, int count) 3726 { 3727 struct ethhdr *data = (struct ethhdr *)skb->data; 3728 struct iphdr *iph = ip_hdr(skb); 3729 __be16 *layer4hdr = (__be16 *)((u32 *)iph + iph->ihl); 3730 int layer4_xor = 0; 3731 3732 if (skb->protocol == htons(ETH_P_IP)) { 3733 if (!(iph->frag_off & htons(IP_MF|IP_OFFSET)) && 3734 (iph->protocol == IPPROTO_TCP || 3735 iph->protocol == IPPROTO_UDP)) { 3736 layer4_xor = ntohs((*layer4hdr ^ *(layer4hdr + 1))); 3737 } 3738 return (layer4_xor ^ 3739 ((ntohl(iph->saddr ^ iph->daddr)) & 0xffff)) % count; 3740 3741 } 3742 3743 return (data->h_dest[5] ^ bond_dev->dev_addr[5]) % count; 3744 } 3745 3746 /* 3747 * Hash for the output device based upon layer 2 data 3748 */ 3749 static int bond_xmit_hash_policy_l2(struct sk_buff *skb, 3750 struct net_device *bond_dev, int count) 3751 { 3752 struct ethhdr *data = (struct ethhdr *)skb->data; 3753 3754 return (data->h_dest[5] ^ bond_dev->dev_addr[5]) % count; 3755 } 3756 3757 /*-------------------------- Device entry points ----------------------------*/ 3758 3759 static int bond_open(struct net_device *bond_dev) 3760 { 3761 struct bonding *bond = bond_dev->priv; 3762 3763 bond->kill_timers = 0; 3764 3765 if ((bond->params.mode == BOND_MODE_TLB) || 3766 (bond->params.mode == BOND_MODE_ALB)) { 3767 /* bond_alb_initialize must be called before the timer 3768 * is started. 3769 */ 3770 if (bond_alb_initialize(bond, (bond->params.mode == BOND_MODE_ALB))) { 3771 /* something went wrong - fail the open operation */ 3772 return -1; 3773 } 3774 3775 INIT_DELAYED_WORK(&bond->alb_work, bond_alb_monitor); 3776 queue_delayed_work(bond->wq, &bond->alb_work, 0); 3777 } 3778 3779 if (bond->params.miimon) { /* link check interval, in milliseconds. */ 3780 INIT_DELAYED_WORK(&bond->mii_work, bond_mii_monitor); 3781 queue_delayed_work(bond->wq, &bond->mii_work, 0); 3782 } 3783 3784 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */ 3785 if (bond->params.mode == BOND_MODE_ACTIVEBACKUP) 3786 INIT_DELAYED_WORK(&bond->arp_work, 3787 bond_activebackup_arp_mon); 3788 else 3789 INIT_DELAYED_WORK(&bond->arp_work, 3790 bond_loadbalance_arp_mon); 3791 3792 queue_delayed_work(bond->wq, &bond->arp_work, 0); 3793 if (bond->params.arp_validate) 3794 bond_register_arp(bond); 3795 } 3796 3797 if (bond->params.mode == BOND_MODE_8023AD) { 3798 INIT_DELAYED_WORK(&bond->ad_work, bond_3ad_state_machine_handler); 3799 queue_delayed_work(bond->wq, &bond->ad_work, 0); 3800 /* register to receive LACPDUs */ 3801 bond_register_lacpdu(bond); 3802 } 3803 3804 return 0; 3805 } 3806 3807 static int bond_close(struct net_device *bond_dev) 3808 { 3809 struct bonding *bond = bond_dev->priv; 3810 3811 if (bond->params.mode == BOND_MODE_8023AD) { 3812 /* Unregister the receive of LACPDUs */ 3813 bond_unregister_lacpdu(bond); 3814 } 3815 3816 if (bond->params.arp_validate) 3817 bond_unregister_arp(bond); 3818 3819 write_lock_bh(&bond->lock); 3820 3821 bond->send_grat_arp = 0; 3822 3823 /* signal timers not to re-arm */ 3824 bond->kill_timers = 1; 3825 3826 write_unlock_bh(&bond->lock); 3827 3828 if (bond->params.miimon) { /* link check interval, in milliseconds. */ 3829 cancel_delayed_work(&bond->mii_work); 3830 } 3831 3832 if (bond->params.arp_interval) { /* arp interval, in milliseconds. */ 3833 cancel_delayed_work(&bond->arp_work); 3834 } 3835 3836 switch (bond->params.mode) { 3837 case BOND_MODE_8023AD: 3838 cancel_delayed_work(&bond->ad_work); 3839 break; 3840 case BOND_MODE_TLB: 3841 case BOND_MODE_ALB: 3842 cancel_delayed_work(&bond->alb_work); 3843 break; 3844 default: 3845 break; 3846 } 3847 3848 3849 if ((bond->params.mode == BOND_MODE_TLB) || 3850 (bond->params.mode == BOND_MODE_ALB)) { 3851 /* Must be called only after all 3852 * slaves have been released 3853 */ 3854 bond_alb_deinitialize(bond); 3855 } 3856 3857 return 0; 3858 } 3859 3860 static struct net_device_stats *bond_get_stats(struct net_device *bond_dev) 3861 { 3862 struct bonding *bond = bond_dev->priv; 3863 struct net_device_stats *stats = &(bond->stats), *sstats; 3864 struct net_device_stats local_stats; 3865 struct slave *slave; 3866 int i; 3867 3868 memset(&local_stats, 0, sizeof(struct net_device_stats)); 3869 3870 read_lock_bh(&bond->lock); 3871 3872 bond_for_each_slave(bond, slave, i) { 3873 sstats = slave->dev->get_stats(slave->dev); 3874 local_stats.rx_packets += sstats->rx_packets; 3875 local_stats.rx_bytes += sstats->rx_bytes; 3876 local_stats.rx_errors += sstats->rx_errors; 3877 local_stats.rx_dropped += sstats->rx_dropped; 3878 3879 local_stats.tx_packets += sstats->tx_packets; 3880 local_stats.tx_bytes += sstats->tx_bytes; 3881 local_stats.tx_errors += sstats->tx_errors; 3882 local_stats.tx_dropped += sstats->tx_dropped; 3883 3884 local_stats.multicast += sstats->multicast; 3885 local_stats.collisions += sstats->collisions; 3886 3887 local_stats.rx_length_errors += sstats->rx_length_errors; 3888 local_stats.rx_over_errors += sstats->rx_over_errors; 3889 local_stats.rx_crc_errors += sstats->rx_crc_errors; 3890 local_stats.rx_frame_errors += sstats->rx_frame_errors; 3891 local_stats.rx_fifo_errors += sstats->rx_fifo_errors; 3892 local_stats.rx_missed_errors += sstats->rx_missed_errors; 3893 3894 local_stats.tx_aborted_errors += sstats->tx_aborted_errors; 3895 local_stats.tx_carrier_errors += sstats->tx_carrier_errors; 3896 local_stats.tx_fifo_errors += sstats->tx_fifo_errors; 3897 local_stats.tx_heartbeat_errors += sstats->tx_heartbeat_errors; 3898 local_stats.tx_window_errors += sstats->tx_window_errors; 3899 } 3900 3901 memcpy(stats, &local_stats, sizeof(struct net_device_stats)); 3902 3903 read_unlock_bh(&bond->lock); 3904 3905 return stats; 3906 } 3907 3908 static int bond_do_ioctl(struct net_device *bond_dev, struct ifreq *ifr, int cmd) 3909 { 3910 struct net_device *slave_dev = NULL; 3911 struct ifbond k_binfo; 3912 struct ifbond __user *u_binfo = NULL; 3913 struct ifslave k_sinfo; 3914 struct ifslave __user *u_sinfo = NULL; 3915 struct mii_ioctl_data *mii = NULL; 3916 int res = 0; 3917 3918 dprintk("bond_ioctl: master=%s, cmd=%d\n", 3919 bond_dev->name, cmd); 3920 3921 switch (cmd) { 3922 case SIOCGMIIPHY: 3923 mii = if_mii(ifr); 3924 if (!mii) { 3925 return -EINVAL; 3926 } 3927 mii->phy_id = 0; 3928 /* Fall Through */ 3929 case SIOCGMIIREG: 3930 /* 3931 * We do this again just in case we were called by SIOCGMIIREG 3932 * instead of SIOCGMIIPHY. 3933 */ 3934 mii = if_mii(ifr); 3935 if (!mii) { 3936 return -EINVAL; 3937 } 3938 3939 if (mii->reg_num == 1) { 3940 struct bonding *bond = bond_dev->priv; 3941 mii->val_out = 0; 3942 read_lock(&bond->lock); 3943 read_lock(&bond->curr_slave_lock); 3944 if (netif_carrier_ok(bond->dev)) { 3945 mii->val_out = BMSR_LSTATUS; 3946 } 3947 read_unlock(&bond->curr_slave_lock); 3948 read_unlock(&bond->lock); 3949 } 3950 3951 return 0; 3952 case BOND_INFO_QUERY_OLD: 3953 case SIOCBONDINFOQUERY: 3954 u_binfo = (struct ifbond __user *)ifr->ifr_data; 3955 3956 if (copy_from_user(&k_binfo, u_binfo, sizeof(ifbond))) { 3957 return -EFAULT; 3958 } 3959 3960 res = bond_info_query(bond_dev, &k_binfo); 3961 if (res == 0) { 3962 if (copy_to_user(u_binfo, &k_binfo, sizeof(ifbond))) { 3963 return -EFAULT; 3964 } 3965 } 3966 3967 return res; 3968 case BOND_SLAVE_INFO_QUERY_OLD: 3969 case SIOCBONDSLAVEINFOQUERY: 3970 u_sinfo = (struct ifslave __user *)ifr->ifr_data; 3971 3972 if (copy_from_user(&k_sinfo, u_sinfo, sizeof(ifslave))) { 3973 return -EFAULT; 3974 } 3975 3976 res = bond_slave_info_query(bond_dev, &k_sinfo); 3977 if (res == 0) { 3978 if (copy_to_user(u_sinfo, &k_sinfo, sizeof(ifslave))) { 3979 return -EFAULT; 3980 } 3981 } 3982 3983 return res; 3984 default: 3985 /* Go on */ 3986 break; 3987 } 3988 3989 if (!capable(CAP_NET_ADMIN)) { 3990 return -EPERM; 3991 } 3992 3993 down_write(&(bonding_rwsem)); 3994 slave_dev = dev_get_by_name(&init_net, ifr->ifr_slave); 3995 3996 dprintk("slave_dev=%p: \n", slave_dev); 3997 3998 if (!slave_dev) { 3999 res = -ENODEV; 4000 } else { 4001 dprintk("slave_dev->name=%s: \n", slave_dev->name); 4002 switch (cmd) { 4003 case BOND_ENSLAVE_OLD: 4004 case SIOCBONDENSLAVE: 4005 res = bond_enslave(bond_dev, slave_dev); 4006 break; 4007 case BOND_RELEASE_OLD: 4008 case SIOCBONDRELEASE: 4009 res = bond_release(bond_dev, slave_dev); 4010 break; 4011 case BOND_SETHWADDR_OLD: 4012 case SIOCBONDSETHWADDR: 4013 res = bond_sethwaddr(bond_dev, slave_dev); 4014 break; 4015 case BOND_CHANGE_ACTIVE_OLD: 4016 case SIOCBONDCHANGEACTIVE: 4017 res = bond_ioctl_change_active(bond_dev, slave_dev); 4018 break; 4019 default: 4020 res = -EOPNOTSUPP; 4021 } 4022 4023 dev_put(slave_dev); 4024 } 4025 4026 up_write(&(bonding_rwsem)); 4027 return res; 4028 } 4029 4030 static void bond_set_multicast_list(struct net_device *bond_dev) 4031 { 4032 struct bonding *bond = bond_dev->priv; 4033 struct dev_mc_list *dmi; 4034 4035 /* 4036 * Do promisc before checking multicast_mode 4037 */ 4038 if ((bond_dev->flags & IFF_PROMISC) && !(bond->flags & IFF_PROMISC)) { 4039 /* 4040 * FIXME: Need to handle the error when one of the multi-slaves 4041 * encounters error. 4042 */ 4043 bond_set_promiscuity(bond, 1); 4044 } 4045 4046 if (!(bond_dev->flags & IFF_PROMISC) && (bond->flags & IFF_PROMISC)) { 4047 bond_set_promiscuity(bond, -1); 4048 } 4049 4050 /* set allmulti flag to slaves */ 4051 if ((bond_dev->flags & IFF_ALLMULTI) && !(bond->flags & IFF_ALLMULTI)) { 4052 /* 4053 * FIXME: Need to handle the error when one of the multi-slaves 4054 * encounters error. 4055 */ 4056 bond_set_allmulti(bond, 1); 4057 } 4058 4059 if (!(bond_dev->flags & IFF_ALLMULTI) && (bond->flags & IFF_ALLMULTI)) { 4060 bond_set_allmulti(bond, -1); 4061 } 4062 4063 read_lock(&bond->lock); 4064 4065 bond->flags = bond_dev->flags; 4066 4067 /* looking for addresses to add to slaves' mc list */ 4068 for (dmi = bond_dev->mc_list; dmi; dmi = dmi->next) { 4069 if (!bond_mc_list_find_dmi(dmi, bond->mc_list)) { 4070 bond_mc_add(bond, dmi->dmi_addr, dmi->dmi_addrlen); 4071 } 4072 } 4073 4074 /* looking for addresses to delete from slaves' list */ 4075 for (dmi = bond->mc_list; dmi; dmi = dmi->next) { 4076 if (!bond_mc_list_find_dmi(dmi, bond_dev->mc_list)) { 4077 bond_mc_delete(bond, dmi->dmi_addr, dmi->dmi_addrlen); 4078 } 4079 } 4080 4081 /* save master's multicast list */ 4082 bond_mc_list_destroy(bond); 4083 bond_mc_list_copy(bond_dev->mc_list, bond, GFP_ATOMIC); 4084 4085 read_unlock(&bond->lock); 4086 } 4087 4088 /* 4089 * Change the MTU of all of a master's slaves to match the master 4090 */ 4091 static int bond_change_mtu(struct net_device *bond_dev, int new_mtu) 4092 { 4093 struct bonding *bond = bond_dev->priv; 4094 struct slave *slave, *stop_at; 4095 int res = 0; 4096 int i; 4097 4098 dprintk("bond=%p, name=%s, new_mtu=%d\n", bond, 4099 (bond_dev ? bond_dev->name : "None"), new_mtu); 4100 4101 /* Can't hold bond->lock with bh disabled here since 4102 * some base drivers panic. On the other hand we can't 4103 * hold bond->lock without bh disabled because we'll 4104 * deadlock. The only solution is to rely on the fact 4105 * that we're under rtnl_lock here, and the slaves 4106 * list won't change. This doesn't solve the problem 4107 * of setting the slave's MTU while it is 4108 * transmitting, but the assumption is that the base 4109 * driver can handle that. 4110 * 4111 * TODO: figure out a way to safely iterate the slaves 4112 * list, but without holding a lock around the actual 4113 * call to the base driver. 4114 */ 4115 4116 bond_for_each_slave(bond, slave, i) { 4117 dprintk("s %p s->p %p c_m %p\n", slave, 4118 slave->prev, slave->dev->change_mtu); 4119 4120 res = dev_set_mtu(slave->dev, new_mtu); 4121 4122 if (res) { 4123 /* If we failed to set the slave's mtu to the new value 4124 * we must abort the operation even in ACTIVE_BACKUP 4125 * mode, because if we allow the backup slaves to have 4126 * different mtu values than the active slave we'll 4127 * need to change their mtu when doing a failover. That 4128 * means changing their mtu from timer context, which 4129 * is probably not a good idea. 4130 */ 4131 dprintk("err %d %s\n", res, slave->dev->name); 4132 goto unwind; 4133 } 4134 } 4135 4136 bond_dev->mtu = new_mtu; 4137 4138 return 0; 4139 4140 unwind: 4141 /* unwind from head to the slave that failed */ 4142 stop_at = slave; 4143 bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) { 4144 int tmp_res; 4145 4146 tmp_res = dev_set_mtu(slave->dev, bond_dev->mtu); 4147 if (tmp_res) { 4148 dprintk("unwind err %d dev %s\n", tmp_res, 4149 slave->dev->name); 4150 } 4151 } 4152 4153 return res; 4154 } 4155 4156 /* 4157 * Change HW address 4158 * 4159 * Note that many devices must be down to change the HW address, and 4160 * downing the master releases all slaves. We can make bonds full of 4161 * bonding devices to test this, however. 4162 */ 4163 static int bond_set_mac_address(struct net_device *bond_dev, void *addr) 4164 { 4165 struct bonding *bond = bond_dev->priv; 4166 struct sockaddr *sa = addr, tmp_sa; 4167 struct slave *slave, *stop_at; 4168 int res = 0; 4169 int i; 4170 4171 dprintk("bond=%p, name=%s\n", bond, (bond_dev ? bond_dev->name : "None")); 4172 4173 /* 4174 * If fail_over_mac is set to active, do nothing and return 4175 * success. Returning an error causes ifenslave to fail. 4176 */ 4177 if (bond->params.fail_over_mac == BOND_FOM_ACTIVE) 4178 return 0; 4179 4180 if (!is_valid_ether_addr(sa->sa_data)) { 4181 return -EADDRNOTAVAIL; 4182 } 4183 4184 /* Can't hold bond->lock with bh disabled here since 4185 * some base drivers panic. On the other hand we can't 4186 * hold bond->lock without bh disabled because we'll 4187 * deadlock. The only solution is to rely on the fact 4188 * that we're under rtnl_lock here, and the slaves 4189 * list won't change. This doesn't solve the problem 4190 * of setting the slave's hw address while it is 4191 * transmitting, but the assumption is that the base 4192 * driver can handle that. 4193 * 4194 * TODO: figure out a way to safely iterate the slaves 4195 * list, but without holding a lock around the actual 4196 * call to the base driver. 4197 */ 4198 4199 bond_for_each_slave(bond, slave, i) { 4200 dprintk("slave %p %s\n", slave, slave->dev->name); 4201 4202 if (slave->dev->set_mac_address == NULL) { 4203 res = -EOPNOTSUPP; 4204 dprintk("EOPNOTSUPP %s\n", slave->dev->name); 4205 goto unwind; 4206 } 4207 4208 res = dev_set_mac_address(slave->dev, addr); 4209 if (res) { 4210 /* TODO: consider downing the slave 4211 * and retry ? 4212 * User should expect communications 4213 * breakage anyway until ARP finish 4214 * updating, so... 4215 */ 4216 dprintk("err %d %s\n", res, slave->dev->name); 4217 goto unwind; 4218 } 4219 } 4220 4221 /* success */ 4222 memcpy(bond_dev->dev_addr, sa->sa_data, bond_dev->addr_len); 4223 return 0; 4224 4225 unwind: 4226 memcpy(tmp_sa.sa_data, bond_dev->dev_addr, bond_dev->addr_len); 4227 tmp_sa.sa_family = bond_dev->type; 4228 4229 /* unwind from head to the slave that failed */ 4230 stop_at = slave; 4231 bond_for_each_slave_from_to(bond, slave, i, bond->first_slave, stop_at) { 4232 int tmp_res; 4233 4234 tmp_res = dev_set_mac_address(slave->dev, &tmp_sa); 4235 if (tmp_res) { 4236 dprintk("unwind err %d dev %s\n", tmp_res, 4237 slave->dev->name); 4238 } 4239 } 4240 4241 return res; 4242 } 4243 4244 static int bond_xmit_roundrobin(struct sk_buff *skb, struct net_device *bond_dev) 4245 { 4246 struct bonding *bond = bond_dev->priv; 4247 struct slave *slave, *start_at; 4248 int i, slave_no, res = 1; 4249 4250 read_lock(&bond->lock); 4251 4252 if (!BOND_IS_OK(bond)) { 4253 goto out; 4254 } 4255 4256 /* 4257 * Concurrent TX may collide on rr_tx_counter; we accept that 4258 * as being rare enough not to justify using an atomic op here 4259 */ 4260 slave_no = bond->rr_tx_counter++ % bond->slave_cnt; 4261 4262 bond_for_each_slave(bond, slave, i) { 4263 slave_no--; 4264 if (slave_no < 0) { 4265 break; 4266 } 4267 } 4268 4269 start_at = slave; 4270 bond_for_each_slave_from(bond, slave, i, start_at) { 4271 if (IS_UP(slave->dev) && 4272 (slave->link == BOND_LINK_UP) && 4273 (slave->state == BOND_STATE_ACTIVE)) { 4274 res = bond_dev_queue_xmit(bond, skb, slave->dev); 4275 break; 4276 } 4277 } 4278 4279 out: 4280 if (res) { 4281 /* no suitable interface, frame not sent */ 4282 dev_kfree_skb(skb); 4283 } 4284 read_unlock(&bond->lock); 4285 return 0; 4286 } 4287 4288 4289 /* 4290 * in active-backup mode, we know that bond->curr_active_slave is always valid if 4291 * the bond has a usable interface. 4292 */ 4293 static int bond_xmit_activebackup(struct sk_buff *skb, struct net_device *bond_dev) 4294 { 4295 struct bonding *bond = bond_dev->priv; 4296 int res = 1; 4297 4298 read_lock(&bond->lock); 4299 read_lock(&bond->curr_slave_lock); 4300 4301 if (!BOND_IS_OK(bond)) { 4302 goto out; 4303 } 4304 4305 if (!bond->curr_active_slave) 4306 goto out; 4307 4308 res = bond_dev_queue_xmit(bond, skb, bond->curr_active_slave->dev); 4309 4310 out: 4311 if (res) { 4312 /* no suitable interface, frame not sent */ 4313 dev_kfree_skb(skb); 4314 } 4315 read_unlock(&bond->curr_slave_lock); 4316 read_unlock(&bond->lock); 4317 return 0; 4318 } 4319 4320 /* 4321 * In bond_xmit_xor() , we determine the output device by using a pre- 4322 * determined xmit_hash_policy(), If the selected device is not enabled, 4323 * find the next active slave. 4324 */ 4325 static int bond_xmit_xor(struct sk_buff *skb, struct net_device *bond_dev) 4326 { 4327 struct bonding *bond = bond_dev->priv; 4328 struct slave *slave, *start_at; 4329 int slave_no; 4330 int i; 4331 int res = 1; 4332 4333 read_lock(&bond->lock); 4334 4335 if (!BOND_IS_OK(bond)) { 4336 goto out; 4337 } 4338 4339 slave_no = bond->xmit_hash_policy(skb, bond_dev, bond->slave_cnt); 4340 4341 bond_for_each_slave(bond, slave, i) { 4342 slave_no--; 4343 if (slave_no < 0) { 4344 break; 4345 } 4346 } 4347 4348 start_at = slave; 4349 4350 bond_for_each_slave_from(bond, slave, i, start_at) { 4351 if (IS_UP(slave->dev) && 4352 (slave->link == BOND_LINK_UP) && 4353 (slave->state == BOND_STATE_ACTIVE)) { 4354 res = bond_dev_queue_xmit(bond, skb, slave->dev); 4355 break; 4356 } 4357 } 4358 4359 out: 4360 if (res) { 4361 /* no suitable interface, frame not sent */ 4362 dev_kfree_skb(skb); 4363 } 4364 read_unlock(&bond->lock); 4365 return 0; 4366 } 4367 4368 /* 4369 * in broadcast mode, we send everything to all usable interfaces. 4370 */ 4371 static int bond_xmit_broadcast(struct sk_buff *skb, struct net_device *bond_dev) 4372 { 4373 struct bonding *bond = bond_dev->priv; 4374 struct slave *slave, *start_at; 4375 struct net_device *tx_dev = NULL; 4376 int i; 4377 int res = 1; 4378 4379 read_lock(&bond->lock); 4380 4381 if (!BOND_IS_OK(bond)) { 4382 goto out; 4383 } 4384 4385 read_lock(&bond->curr_slave_lock); 4386 start_at = bond->curr_active_slave; 4387 read_unlock(&bond->curr_slave_lock); 4388 4389 if (!start_at) { 4390 goto out; 4391 } 4392 4393 bond_for_each_slave_from(bond, slave, i, start_at) { 4394 if (IS_UP(slave->dev) && 4395 (slave->link == BOND_LINK_UP) && 4396 (slave->state == BOND_STATE_ACTIVE)) { 4397 if (tx_dev) { 4398 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); 4399 if (!skb2) { 4400 printk(KERN_ERR DRV_NAME 4401 ": %s: Error: bond_xmit_broadcast(): " 4402 "skb_clone() failed\n", 4403 bond_dev->name); 4404 continue; 4405 } 4406 4407 res = bond_dev_queue_xmit(bond, skb2, tx_dev); 4408 if (res) { 4409 dev_kfree_skb(skb2); 4410 continue; 4411 } 4412 } 4413 tx_dev = slave->dev; 4414 } 4415 } 4416 4417 if (tx_dev) { 4418 res = bond_dev_queue_xmit(bond, skb, tx_dev); 4419 } 4420 4421 out: 4422 if (res) { 4423 /* no suitable interface, frame not sent */ 4424 dev_kfree_skb(skb); 4425 } 4426 /* frame sent to all suitable interfaces */ 4427 read_unlock(&bond->lock); 4428 return 0; 4429 } 4430 4431 /*------------------------- Device initialization ---------------------------*/ 4432 4433 static void bond_set_xmit_hash_policy(struct bonding *bond) 4434 { 4435 switch (bond->params.xmit_policy) { 4436 case BOND_XMIT_POLICY_LAYER23: 4437 bond->xmit_hash_policy = bond_xmit_hash_policy_l23; 4438 break; 4439 case BOND_XMIT_POLICY_LAYER34: 4440 bond->xmit_hash_policy = bond_xmit_hash_policy_l34; 4441 break; 4442 case BOND_XMIT_POLICY_LAYER2: 4443 default: 4444 bond->xmit_hash_policy = bond_xmit_hash_policy_l2; 4445 break; 4446 } 4447 } 4448 4449 /* 4450 * set bond mode specific net device operations 4451 */ 4452 void bond_set_mode_ops(struct bonding *bond, int mode) 4453 { 4454 struct net_device *bond_dev = bond->dev; 4455 4456 switch (mode) { 4457 case BOND_MODE_ROUNDROBIN: 4458 bond_dev->hard_start_xmit = bond_xmit_roundrobin; 4459 break; 4460 case BOND_MODE_ACTIVEBACKUP: 4461 bond_dev->hard_start_xmit = bond_xmit_activebackup; 4462 break; 4463 case BOND_MODE_XOR: 4464 bond_dev->hard_start_xmit = bond_xmit_xor; 4465 bond_set_xmit_hash_policy(bond); 4466 break; 4467 case BOND_MODE_BROADCAST: 4468 bond_dev->hard_start_xmit = bond_xmit_broadcast; 4469 break; 4470 case BOND_MODE_8023AD: 4471 bond_set_master_3ad_flags(bond); 4472 bond_dev->hard_start_xmit = bond_3ad_xmit_xor; 4473 bond_set_xmit_hash_policy(bond); 4474 break; 4475 case BOND_MODE_ALB: 4476 bond_set_master_alb_flags(bond); 4477 /* FALLTHRU */ 4478 case BOND_MODE_TLB: 4479 bond_dev->hard_start_xmit = bond_alb_xmit; 4480 bond_dev->set_mac_address = bond_alb_set_mac_address; 4481 break; 4482 default: 4483 /* Should never happen, mode already checked */ 4484 printk(KERN_ERR DRV_NAME 4485 ": %s: Error: Unknown bonding mode %d\n", 4486 bond_dev->name, 4487 mode); 4488 break; 4489 } 4490 } 4491 4492 static void bond_ethtool_get_drvinfo(struct net_device *bond_dev, 4493 struct ethtool_drvinfo *drvinfo) 4494 { 4495 strncpy(drvinfo->driver, DRV_NAME, 32); 4496 strncpy(drvinfo->version, DRV_VERSION, 32); 4497 snprintf(drvinfo->fw_version, 32, "%d", BOND_ABI_VERSION); 4498 } 4499 4500 static const struct ethtool_ops bond_ethtool_ops = { 4501 .get_drvinfo = bond_ethtool_get_drvinfo, 4502 .get_link = ethtool_op_get_link, 4503 .get_tx_csum = ethtool_op_get_tx_csum, 4504 .get_sg = ethtool_op_get_sg, 4505 .get_tso = ethtool_op_get_tso, 4506 .get_ufo = ethtool_op_get_ufo, 4507 .get_flags = ethtool_op_get_flags, 4508 }; 4509 4510 /* 4511 * Does not allocate but creates a /proc entry. 4512 * Allowed to fail. 4513 */ 4514 static int bond_init(struct net_device *bond_dev, struct bond_params *params) 4515 { 4516 struct bonding *bond = bond_dev->priv; 4517 4518 dprintk("Begin bond_init for %s\n", bond_dev->name); 4519 4520 /* initialize rwlocks */ 4521 rwlock_init(&bond->lock); 4522 rwlock_init(&bond->curr_slave_lock); 4523 4524 bond->params = *params; /* copy params struct */ 4525 4526 bond->wq = create_singlethread_workqueue(bond_dev->name); 4527 if (!bond->wq) 4528 return -ENOMEM; 4529 4530 /* Initialize pointers */ 4531 bond->first_slave = NULL; 4532 bond->curr_active_slave = NULL; 4533 bond->current_arp_slave = NULL; 4534 bond->primary_slave = NULL; 4535 bond->dev = bond_dev; 4536 bond->send_grat_arp = 0; 4537 bond->setup_by_slave = 0; 4538 INIT_LIST_HEAD(&bond->vlan_list); 4539 4540 /* Initialize the device entry points */ 4541 bond_dev->open = bond_open; 4542 bond_dev->stop = bond_close; 4543 bond_dev->get_stats = bond_get_stats; 4544 bond_dev->do_ioctl = bond_do_ioctl; 4545 bond_dev->ethtool_ops = &bond_ethtool_ops; 4546 bond_dev->set_multicast_list = bond_set_multicast_list; 4547 bond_dev->change_mtu = bond_change_mtu; 4548 bond_dev->set_mac_address = bond_set_mac_address; 4549 bond_dev->validate_addr = NULL; 4550 4551 bond_set_mode_ops(bond, bond->params.mode); 4552 4553 bond_dev->destructor = free_netdev; 4554 4555 /* Initialize the device options */ 4556 bond_dev->tx_queue_len = 0; 4557 bond_dev->flags |= IFF_MASTER|IFF_MULTICAST; 4558 bond_dev->priv_flags |= IFF_BONDING; 4559 4560 /* At first, we block adding VLANs. That's the only way to 4561 * prevent problems that occur when adding VLANs over an 4562 * empty bond. The block will be removed once non-challenged 4563 * slaves are enslaved. 4564 */ 4565 bond_dev->features |= NETIF_F_VLAN_CHALLENGED; 4566 4567 /* don't acquire bond device's netif_tx_lock when 4568 * transmitting */ 4569 bond_dev->features |= NETIF_F_LLTX; 4570 4571 /* By default, we declare the bond to be fully 4572 * VLAN hardware accelerated capable. Special 4573 * care is taken in the various xmit functions 4574 * when there are slaves that are not hw accel 4575 * capable 4576 */ 4577 bond_dev->vlan_rx_register = bond_vlan_rx_register; 4578 bond_dev->vlan_rx_add_vid = bond_vlan_rx_add_vid; 4579 bond_dev->vlan_rx_kill_vid = bond_vlan_rx_kill_vid; 4580 bond_dev->features |= (NETIF_F_HW_VLAN_TX | 4581 NETIF_F_HW_VLAN_RX | 4582 NETIF_F_HW_VLAN_FILTER); 4583 4584 #ifdef CONFIG_PROC_FS 4585 bond_create_proc_entry(bond); 4586 #endif 4587 list_add_tail(&bond->bond_list, &bond_dev_list); 4588 4589 return 0; 4590 } 4591 4592 /* De-initialize device specific data. 4593 * Caller must hold rtnl_lock. 4594 */ 4595 static void bond_deinit(struct net_device *bond_dev) 4596 { 4597 struct bonding *bond = bond_dev->priv; 4598 4599 list_del(&bond->bond_list); 4600 4601 #ifdef CONFIG_PROC_FS 4602 bond_remove_proc_entry(bond); 4603 #endif 4604 } 4605 4606 static void bond_work_cancel_all(struct bonding *bond) 4607 { 4608 write_lock_bh(&bond->lock); 4609 bond->kill_timers = 1; 4610 write_unlock_bh(&bond->lock); 4611 4612 if (bond->params.miimon && delayed_work_pending(&bond->mii_work)) 4613 cancel_delayed_work(&bond->mii_work); 4614 4615 if (bond->params.arp_interval && delayed_work_pending(&bond->arp_work)) 4616 cancel_delayed_work(&bond->arp_work); 4617 4618 if (bond->params.mode == BOND_MODE_ALB && 4619 delayed_work_pending(&bond->alb_work)) 4620 cancel_delayed_work(&bond->alb_work); 4621 4622 if (bond->params.mode == BOND_MODE_8023AD && 4623 delayed_work_pending(&bond->ad_work)) 4624 cancel_delayed_work(&bond->ad_work); 4625 } 4626 4627 /* Unregister and free all bond devices. 4628 * Caller must hold rtnl_lock. 4629 */ 4630 static void bond_free_all(void) 4631 { 4632 struct bonding *bond, *nxt; 4633 4634 list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list) { 4635 struct net_device *bond_dev = bond->dev; 4636 4637 bond_work_cancel_all(bond); 4638 netif_addr_lock_bh(bond_dev); 4639 bond_mc_list_destroy(bond); 4640 netif_addr_unlock_bh(bond_dev); 4641 /* Release the bonded slaves */ 4642 bond_release_all(bond_dev); 4643 bond_destroy(bond); 4644 } 4645 4646 #ifdef CONFIG_PROC_FS 4647 bond_destroy_proc_dir(); 4648 #endif 4649 } 4650 4651 /*------------------------- Module initialization ---------------------------*/ 4652 4653 /* 4654 * Convert string input module parms. Accept either the 4655 * number of the mode or its string name. A bit complicated because 4656 * some mode names are substrings of other names, and calls from sysfs 4657 * may have whitespace in the name (trailing newlines, for example). 4658 */ 4659 int bond_parse_parm(const char *buf, struct bond_parm_tbl *tbl) 4660 { 4661 int mode = -1, i, rv; 4662 char *p, modestr[BOND_MAX_MODENAME_LEN + 1] = { 0, }; 4663 4664 for (p = (char *)buf; *p; p++) 4665 if (!(isdigit(*p) || isspace(*p))) 4666 break; 4667 4668 if (*p) 4669 rv = sscanf(buf, "%20s", modestr); 4670 else 4671 rv = sscanf(buf, "%d", &mode); 4672 4673 if (!rv) 4674 return -1; 4675 4676 for (i = 0; tbl[i].modename; i++) { 4677 if (mode == tbl[i].mode) 4678 return tbl[i].mode; 4679 if (strcmp(modestr, tbl[i].modename) == 0) 4680 return tbl[i].mode; 4681 } 4682 4683 return -1; 4684 } 4685 4686 static int bond_check_params(struct bond_params *params) 4687 { 4688 int arp_validate_value, fail_over_mac_value; 4689 4690 /* 4691 * Convert string parameters. 4692 */ 4693 if (mode) { 4694 bond_mode = bond_parse_parm(mode, bond_mode_tbl); 4695 if (bond_mode == -1) { 4696 printk(KERN_ERR DRV_NAME 4697 ": Error: Invalid bonding mode \"%s\"\n", 4698 mode == NULL ? "NULL" : mode); 4699 return -EINVAL; 4700 } 4701 } 4702 4703 if (xmit_hash_policy) { 4704 if ((bond_mode != BOND_MODE_XOR) && 4705 (bond_mode != BOND_MODE_8023AD)) { 4706 printk(KERN_INFO DRV_NAME 4707 ": xor_mode param is irrelevant in mode %s\n", 4708 bond_mode_name(bond_mode)); 4709 } else { 4710 xmit_hashtype = bond_parse_parm(xmit_hash_policy, 4711 xmit_hashtype_tbl); 4712 if (xmit_hashtype == -1) { 4713 printk(KERN_ERR DRV_NAME 4714 ": Error: Invalid xmit_hash_policy \"%s\"\n", 4715 xmit_hash_policy == NULL ? "NULL" : 4716 xmit_hash_policy); 4717 return -EINVAL; 4718 } 4719 } 4720 } 4721 4722 if (lacp_rate) { 4723 if (bond_mode != BOND_MODE_8023AD) { 4724 printk(KERN_INFO DRV_NAME 4725 ": lacp_rate param is irrelevant in mode %s\n", 4726 bond_mode_name(bond_mode)); 4727 } else { 4728 lacp_fast = bond_parse_parm(lacp_rate, bond_lacp_tbl); 4729 if (lacp_fast == -1) { 4730 printk(KERN_ERR DRV_NAME 4731 ": Error: Invalid lacp rate \"%s\"\n", 4732 lacp_rate == NULL ? "NULL" : lacp_rate); 4733 return -EINVAL; 4734 } 4735 } 4736 } 4737 4738 if (max_bonds < 0 || max_bonds > INT_MAX) { 4739 printk(KERN_WARNING DRV_NAME 4740 ": Warning: max_bonds (%d) not in range %d-%d, so it " 4741 "was reset to BOND_DEFAULT_MAX_BONDS (%d)\n", 4742 max_bonds, 0, INT_MAX, BOND_DEFAULT_MAX_BONDS); 4743 max_bonds = BOND_DEFAULT_MAX_BONDS; 4744 } 4745 4746 if (miimon < 0) { 4747 printk(KERN_WARNING DRV_NAME 4748 ": Warning: miimon module parameter (%d), " 4749 "not in range 0-%d, so it was reset to %d\n", 4750 miimon, INT_MAX, BOND_LINK_MON_INTERV); 4751 miimon = BOND_LINK_MON_INTERV; 4752 } 4753 4754 if (updelay < 0) { 4755 printk(KERN_WARNING DRV_NAME 4756 ": Warning: updelay module parameter (%d), " 4757 "not in range 0-%d, so it was reset to 0\n", 4758 updelay, INT_MAX); 4759 updelay = 0; 4760 } 4761 4762 if (downdelay < 0) { 4763 printk(KERN_WARNING DRV_NAME 4764 ": Warning: downdelay module parameter (%d), " 4765 "not in range 0-%d, so it was reset to 0\n", 4766 downdelay, INT_MAX); 4767 downdelay = 0; 4768 } 4769 4770 if ((use_carrier != 0) && (use_carrier != 1)) { 4771 printk(KERN_WARNING DRV_NAME 4772 ": Warning: use_carrier module parameter (%d), " 4773 "not of valid value (0/1), so it was set to 1\n", 4774 use_carrier); 4775 use_carrier = 1; 4776 } 4777 4778 if (num_grat_arp < 0 || num_grat_arp > 255) { 4779 printk(KERN_WARNING DRV_NAME 4780 ": Warning: num_grat_arp (%d) not in range 0-255 so it " 4781 "was reset to 1 \n", num_grat_arp); 4782 num_grat_arp = 1; 4783 } 4784 4785 /* reset values for 802.3ad */ 4786 if (bond_mode == BOND_MODE_8023AD) { 4787 if (!miimon) { 4788 printk(KERN_WARNING DRV_NAME 4789 ": Warning: miimon must be specified, " 4790 "otherwise bonding will not detect link " 4791 "failure, speed and duplex which are " 4792 "essential for 802.3ad operation\n"); 4793 printk(KERN_WARNING "Forcing miimon to 100msec\n"); 4794 miimon = 100; 4795 } 4796 } 4797 4798 /* reset values for TLB/ALB */ 4799 if ((bond_mode == BOND_MODE_TLB) || 4800 (bond_mode == BOND_MODE_ALB)) { 4801 if (!miimon) { 4802 printk(KERN_WARNING DRV_NAME 4803 ": Warning: miimon must be specified, " 4804 "otherwise bonding will not detect link " 4805 "failure and link speed which are essential " 4806 "for TLB/ALB load balancing\n"); 4807 printk(KERN_WARNING "Forcing miimon to 100msec\n"); 4808 miimon = 100; 4809 } 4810 } 4811 4812 if (bond_mode == BOND_MODE_ALB) { 4813 printk(KERN_NOTICE DRV_NAME 4814 ": In ALB mode you might experience client " 4815 "disconnections upon reconnection of a link if the " 4816 "bonding module updelay parameter (%d msec) is " 4817 "incompatible with the forwarding delay time of the " 4818 "switch\n", 4819 updelay); 4820 } 4821 4822 if (!miimon) { 4823 if (updelay || downdelay) { 4824 /* just warn the user the up/down delay will have 4825 * no effect since miimon is zero... 4826 */ 4827 printk(KERN_WARNING DRV_NAME 4828 ": Warning: miimon module parameter not set " 4829 "and updelay (%d) or downdelay (%d) module " 4830 "parameter is set; updelay and downdelay have " 4831 "no effect unless miimon is set\n", 4832 updelay, downdelay); 4833 } 4834 } else { 4835 /* don't allow arp monitoring */ 4836 if (arp_interval) { 4837 printk(KERN_WARNING DRV_NAME 4838 ": Warning: miimon (%d) and arp_interval (%d) " 4839 "can't be used simultaneously, disabling ARP " 4840 "monitoring\n", 4841 miimon, arp_interval); 4842 arp_interval = 0; 4843 } 4844 4845 if ((updelay % miimon) != 0) { 4846 printk(KERN_WARNING DRV_NAME 4847 ": Warning: updelay (%d) is not a multiple " 4848 "of miimon (%d), updelay rounded to %d ms\n", 4849 updelay, miimon, (updelay / miimon) * miimon); 4850 } 4851 4852 updelay /= miimon; 4853 4854 if ((downdelay % miimon) != 0) { 4855 printk(KERN_WARNING DRV_NAME 4856 ": Warning: downdelay (%d) is not a multiple " 4857 "of miimon (%d), downdelay rounded to %d ms\n", 4858 downdelay, miimon, 4859 (downdelay / miimon) * miimon); 4860 } 4861 4862 downdelay /= miimon; 4863 } 4864 4865 if (arp_interval < 0) { 4866 printk(KERN_WARNING DRV_NAME 4867 ": Warning: arp_interval module parameter (%d) " 4868 ", not in range 0-%d, so it was reset to %d\n", 4869 arp_interval, INT_MAX, BOND_LINK_ARP_INTERV); 4870 arp_interval = BOND_LINK_ARP_INTERV; 4871 } 4872 4873 for (arp_ip_count = 0; 4874 (arp_ip_count < BOND_MAX_ARP_TARGETS) && arp_ip_target[arp_ip_count]; 4875 arp_ip_count++) { 4876 /* not complete check, but should be good enough to 4877 catch mistakes */ 4878 if (!isdigit(arp_ip_target[arp_ip_count][0])) { 4879 printk(KERN_WARNING DRV_NAME 4880 ": Warning: bad arp_ip_target module parameter " 4881 "(%s), ARP monitoring will not be performed\n", 4882 arp_ip_target[arp_ip_count]); 4883 arp_interval = 0; 4884 } else { 4885 __be32 ip = in_aton(arp_ip_target[arp_ip_count]); 4886 arp_target[arp_ip_count] = ip; 4887 } 4888 } 4889 4890 if (arp_interval && !arp_ip_count) { 4891 /* don't allow arping if no arp_ip_target given... */ 4892 printk(KERN_WARNING DRV_NAME 4893 ": Warning: arp_interval module parameter (%d) " 4894 "specified without providing an arp_ip_target " 4895 "parameter, arp_interval was reset to 0\n", 4896 arp_interval); 4897 arp_interval = 0; 4898 } 4899 4900 if (arp_validate) { 4901 if (bond_mode != BOND_MODE_ACTIVEBACKUP) { 4902 printk(KERN_ERR DRV_NAME 4903 ": arp_validate only supported in active-backup mode\n"); 4904 return -EINVAL; 4905 } 4906 if (!arp_interval) { 4907 printk(KERN_ERR DRV_NAME 4908 ": arp_validate requires arp_interval\n"); 4909 return -EINVAL; 4910 } 4911 4912 arp_validate_value = bond_parse_parm(arp_validate, 4913 arp_validate_tbl); 4914 if (arp_validate_value == -1) { 4915 printk(KERN_ERR DRV_NAME 4916 ": Error: invalid arp_validate \"%s\"\n", 4917 arp_validate == NULL ? "NULL" : arp_validate); 4918 return -EINVAL; 4919 } 4920 } else 4921 arp_validate_value = 0; 4922 4923 if (miimon) { 4924 printk(KERN_INFO DRV_NAME 4925 ": MII link monitoring set to %d ms\n", 4926 miimon); 4927 } else if (arp_interval) { 4928 int i; 4929 4930 printk(KERN_INFO DRV_NAME 4931 ": ARP monitoring set to %d ms, validate %s, with %d target(s):", 4932 arp_interval, 4933 arp_validate_tbl[arp_validate_value].modename, 4934 arp_ip_count); 4935 4936 for (i = 0; i < arp_ip_count; i++) 4937 printk (" %s", arp_ip_target[i]); 4938 4939 printk("\n"); 4940 4941 } else if (max_bonds) { 4942 /* miimon and arp_interval not set, we need one so things 4943 * work as expected, see bonding.txt for details 4944 */ 4945 printk(KERN_WARNING DRV_NAME 4946 ": Warning: either miimon or arp_interval and " 4947 "arp_ip_target module parameters must be specified, " 4948 "otherwise bonding will not detect link failures! see " 4949 "bonding.txt for details.\n"); 4950 } 4951 4952 if (primary && !USES_PRIMARY(bond_mode)) { 4953 /* currently, using a primary only makes sense 4954 * in active backup, TLB or ALB modes 4955 */ 4956 printk(KERN_WARNING DRV_NAME 4957 ": Warning: %s primary device specified but has no " 4958 "effect in %s mode\n", 4959 primary, bond_mode_name(bond_mode)); 4960 primary = NULL; 4961 } 4962 4963 if (fail_over_mac) { 4964 fail_over_mac_value = bond_parse_parm(fail_over_mac, 4965 fail_over_mac_tbl); 4966 if (fail_over_mac_value == -1) { 4967 printk(KERN_ERR DRV_NAME 4968 ": Error: invalid fail_over_mac \"%s\"\n", 4969 arp_validate == NULL ? "NULL" : arp_validate); 4970 return -EINVAL; 4971 } 4972 4973 if (bond_mode != BOND_MODE_ACTIVEBACKUP) 4974 printk(KERN_WARNING DRV_NAME 4975 ": Warning: fail_over_mac only affects " 4976 "active-backup mode.\n"); 4977 } else { 4978 fail_over_mac_value = BOND_FOM_NONE; 4979 } 4980 4981 /* fill params struct with the proper values */ 4982 params->mode = bond_mode; 4983 params->xmit_policy = xmit_hashtype; 4984 params->miimon = miimon; 4985 params->num_grat_arp = num_grat_arp; 4986 params->arp_interval = arp_interval; 4987 params->arp_validate = arp_validate_value; 4988 params->updelay = updelay; 4989 params->downdelay = downdelay; 4990 params->use_carrier = use_carrier; 4991 params->lacp_fast = lacp_fast; 4992 params->primary[0] = 0; 4993 params->fail_over_mac = fail_over_mac_value; 4994 4995 if (primary) { 4996 strncpy(params->primary, primary, IFNAMSIZ); 4997 params->primary[IFNAMSIZ - 1] = 0; 4998 } 4999 5000 memcpy(params->arp_targets, arp_target, sizeof(arp_target)); 5001 5002 return 0; 5003 } 5004 5005 static struct lock_class_key bonding_netdev_xmit_lock_key; 5006 static struct lock_class_key bonding_netdev_addr_lock_key; 5007 5008 static void bond_set_lockdep_class_one(struct net_device *dev, 5009 struct netdev_queue *txq, 5010 void *_unused) 5011 { 5012 lockdep_set_class(&txq->_xmit_lock, 5013 &bonding_netdev_xmit_lock_key); 5014 } 5015 5016 static void bond_set_lockdep_class(struct net_device *dev) 5017 { 5018 lockdep_set_class(&dev->addr_list_lock, 5019 &bonding_netdev_addr_lock_key); 5020 netdev_for_each_tx_queue(dev, bond_set_lockdep_class_one, NULL); 5021 } 5022 5023 /* Create a new bond based on the specified name and bonding parameters. 5024 * If name is NULL, obtain a suitable "bond%d" name for us. 5025 * Caller must NOT hold rtnl_lock; we need to release it here before we 5026 * set up our sysfs entries. 5027 */ 5028 int bond_create(char *name, struct bond_params *params) 5029 { 5030 struct net_device *bond_dev; 5031 struct bonding *bond; 5032 int res; 5033 5034 rtnl_lock(); 5035 down_write(&bonding_rwsem); 5036 5037 /* Check to see if the bond already exists. */ 5038 if (name) { 5039 list_for_each_entry(bond, &bond_dev_list, bond_list) 5040 if (strnicmp(bond->dev->name, name, IFNAMSIZ) == 0) { 5041 printk(KERN_ERR DRV_NAME 5042 ": cannot add bond %s; it already exists\n", 5043 name); 5044 res = -EPERM; 5045 goto out_rtnl; 5046 } 5047 } 5048 5049 bond_dev = alloc_netdev(sizeof(struct bonding), name ? name : "", 5050 ether_setup); 5051 if (!bond_dev) { 5052 printk(KERN_ERR DRV_NAME 5053 ": %s: eek! can't alloc netdev!\n", 5054 name); 5055 res = -ENOMEM; 5056 goto out_rtnl; 5057 } 5058 5059 if (!name) { 5060 res = dev_alloc_name(bond_dev, "bond%d"); 5061 if (res < 0) 5062 goto out_netdev; 5063 } 5064 5065 /* bond_init() must be called after dev_alloc_name() (for the 5066 * /proc files), but before register_netdevice(), because we 5067 * need to set function pointers. 5068 */ 5069 5070 res = bond_init(bond_dev, params); 5071 if (res < 0) { 5072 goto out_netdev; 5073 } 5074 5075 res = register_netdevice(bond_dev); 5076 if (res < 0) { 5077 goto out_bond; 5078 } 5079 5080 bond_set_lockdep_class(bond_dev); 5081 5082 netif_carrier_off(bond_dev); 5083 5084 up_write(&bonding_rwsem); 5085 rtnl_unlock(); /* allows sysfs registration of net device */ 5086 res = bond_create_sysfs_entry(bond_dev->priv); 5087 if (res < 0) { 5088 rtnl_lock(); 5089 down_write(&bonding_rwsem); 5090 bond_deinit(bond_dev); 5091 unregister_netdevice(bond_dev); 5092 goto out_rtnl; 5093 } 5094 5095 return 0; 5096 5097 out_bond: 5098 bond_deinit(bond_dev); 5099 out_netdev: 5100 free_netdev(bond_dev); 5101 out_rtnl: 5102 up_write(&bonding_rwsem); 5103 rtnl_unlock(); 5104 return res; 5105 } 5106 5107 static int __init bonding_init(void) 5108 { 5109 int i; 5110 int res; 5111 struct bonding *bond; 5112 5113 printk(KERN_INFO "%s", version); 5114 5115 res = bond_check_params(&bonding_defaults); 5116 if (res) { 5117 goto out; 5118 } 5119 5120 #ifdef CONFIG_PROC_FS 5121 bond_create_proc_dir(); 5122 #endif 5123 5124 init_rwsem(&bonding_rwsem); 5125 5126 for (i = 0; i < max_bonds; i++) { 5127 res = bond_create(NULL, &bonding_defaults); 5128 if (res) 5129 goto err; 5130 } 5131 5132 res = bond_create_sysfs(); 5133 if (res) 5134 goto err; 5135 5136 register_netdevice_notifier(&bond_netdev_notifier); 5137 register_inetaddr_notifier(&bond_inetaddr_notifier); 5138 5139 goto out; 5140 err: 5141 list_for_each_entry(bond, &bond_dev_list, bond_list) { 5142 bond_work_cancel_all(bond); 5143 destroy_workqueue(bond->wq); 5144 } 5145 5146 bond_destroy_sysfs(); 5147 5148 rtnl_lock(); 5149 bond_free_all(); 5150 rtnl_unlock(); 5151 out: 5152 return res; 5153 5154 } 5155 5156 static void __exit bonding_exit(void) 5157 { 5158 unregister_netdevice_notifier(&bond_netdev_notifier); 5159 unregister_inetaddr_notifier(&bond_inetaddr_notifier); 5160 5161 bond_destroy_sysfs(); 5162 5163 rtnl_lock(); 5164 bond_free_all(); 5165 rtnl_unlock(); 5166 } 5167 5168 module_init(bonding_init); 5169 module_exit(bonding_exit); 5170 MODULE_LICENSE("GPL"); 5171 MODULE_VERSION(DRV_VERSION); 5172 MODULE_DESCRIPTION(DRV_DESCRIPTION ", v" DRV_VERSION); 5173 MODULE_AUTHOR("Thomas Davis, tadavis@lbl.gov and many others"); 5174 MODULE_SUPPORTED_DEVICE("most ethernet devices"); 5175 5176 /* 5177 * Local variables: 5178 * c-indent-level: 8 5179 * c-basic-offset: 8 5180 * tab-width: 8 5181 * End: 5182 */ 5183 5184