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