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