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