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