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