xref: /linux/drivers/net/bonding/bond_3ad.c (revision 0883c2c06fb5bcf5b9e008270827e63c09a88c1e)
1 /*
2  * Copyright(c) 1999 - 2004 Intel Corporation. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License as published by the Free
6  * Software Foundation; either version 2 of the License, or (at your option)
7  * any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc., 59
16  * Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17  *
18  * The full GNU General Public License is included in this distribution in the
19  * file called LICENSE.
20  *
21  */
22 
23 #include <linux/skbuff.h>
24 #include <linux/if_ether.h>
25 #include <linux/netdevice.h>
26 #include <linux/spinlock.h>
27 #include <linux/ethtool.h>
28 #include <linux/etherdevice.h>
29 #include <linux/if_bonding.h>
30 #include <linux/pkt_sched.h>
31 #include <net/net_namespace.h>
32 #include <net/bonding.h>
33 #include <net/bond_3ad.h>
34 
35 /* General definitions */
36 #define AD_SHORT_TIMEOUT           1
37 #define AD_LONG_TIMEOUT            0
38 #define AD_STANDBY                 0x2
39 #define AD_MAX_TX_IN_SECOND        3
40 #define AD_COLLECTOR_MAX_DELAY     0
41 
42 /* Timer definitions (43.4.4 in the 802.3ad standard) */
43 #define AD_FAST_PERIODIC_TIME      1
44 #define AD_SLOW_PERIODIC_TIME      30
45 #define AD_SHORT_TIMEOUT_TIME      (3*AD_FAST_PERIODIC_TIME)
46 #define AD_LONG_TIMEOUT_TIME       (3*AD_SLOW_PERIODIC_TIME)
47 #define AD_CHURN_DETECTION_TIME    60
48 #define AD_AGGREGATE_WAIT_TIME     2
49 
50 /* Port state definitions (43.4.2.2 in the 802.3ad standard) */
51 #define AD_STATE_LACP_ACTIVITY   0x1
52 #define AD_STATE_LACP_TIMEOUT    0x2
53 #define AD_STATE_AGGREGATION     0x4
54 #define AD_STATE_SYNCHRONIZATION 0x8
55 #define AD_STATE_COLLECTING      0x10
56 #define AD_STATE_DISTRIBUTING    0x20
57 #define AD_STATE_DEFAULTED       0x40
58 #define AD_STATE_EXPIRED         0x80
59 
60 /* Port Variables definitions used by the State Machines (43.4.7 in the
61  * 802.3ad standard)
62  */
63 #define AD_PORT_BEGIN           0x1
64 #define AD_PORT_LACP_ENABLED    0x2
65 #define AD_PORT_ACTOR_CHURN     0x4
66 #define AD_PORT_PARTNER_CHURN   0x8
67 #define AD_PORT_READY           0x10
68 #define AD_PORT_READY_N         0x20
69 #define AD_PORT_MATCHED         0x40
70 #define AD_PORT_STANDBY         0x80
71 #define AD_PORT_SELECTED        0x100
72 #define AD_PORT_MOVED           0x200
73 #define AD_PORT_CHURNED         (AD_PORT_ACTOR_CHURN | AD_PORT_PARTNER_CHURN)
74 
75 /* Port Key definitions
76  * key is determined according to the link speed, duplex and
77  * user key (which is yet not supported)
78  *           --------------------------------------------------------------
79  * Port key  | User key (10 bits)           | Speed (5 bits)      | Duplex|
80  *           --------------------------------------------------------------
81  *           |15                           6|5                   1|0
82  */
83 #define  AD_DUPLEX_KEY_MASKS    0x1
84 #define  AD_SPEED_KEY_MASKS     0x3E
85 #define  AD_USER_KEY_MASKS      0xFFC0
86 
87 enum ad_link_speed_type {
88 	AD_LINK_SPEED_1MBPS = 1,
89 	AD_LINK_SPEED_10MBPS,
90 	AD_LINK_SPEED_100MBPS,
91 	AD_LINK_SPEED_1000MBPS,
92 	AD_LINK_SPEED_2500MBPS,
93 	AD_LINK_SPEED_10000MBPS,
94 	AD_LINK_SPEED_20000MBPS,
95 	AD_LINK_SPEED_40000MBPS,
96 	AD_LINK_SPEED_56000MBPS,
97 	AD_LINK_SPEED_100000MBPS,
98 };
99 
100 /* compare MAC addresses */
101 #define MAC_ADDRESS_EQUAL(A, B)	\
102 	ether_addr_equal_64bits((const u8 *)A, (const u8 *)B)
103 
104 static struct mac_addr null_mac_addr = { { 0, 0, 0, 0, 0, 0 } };
105 static u16 ad_ticks_per_sec;
106 static const int ad_delta_in_ticks = (AD_TIMER_INTERVAL * HZ) / 1000;
107 
108 static const u8 lacpdu_mcast_addr[ETH_ALEN] = MULTICAST_LACPDU_ADDR;
109 
110 /* ================= main 802.3ad protocol functions ================== */
111 static int ad_lacpdu_send(struct port *port);
112 static int ad_marker_send(struct port *port, struct bond_marker *marker);
113 static void ad_mux_machine(struct port *port, bool *update_slave_arr);
114 static void ad_rx_machine(struct lacpdu *lacpdu, struct port *port);
115 static void ad_tx_machine(struct port *port);
116 static void ad_periodic_machine(struct port *port);
117 static void ad_port_selection_logic(struct port *port, bool *update_slave_arr);
118 static void ad_agg_selection_logic(struct aggregator *aggregator,
119 				   bool *update_slave_arr);
120 static void ad_clear_agg(struct aggregator *aggregator);
121 static void ad_initialize_agg(struct aggregator *aggregator);
122 static void ad_initialize_port(struct port *port, int lacp_fast);
123 static void ad_enable_collecting_distributing(struct port *port,
124 					      bool *update_slave_arr);
125 static void ad_disable_collecting_distributing(struct port *port,
126 					       bool *update_slave_arr);
127 static void ad_marker_info_received(struct bond_marker *marker_info,
128 				    struct port *port);
129 static void ad_marker_response_received(struct bond_marker *marker,
130 					struct port *port);
131 static void ad_update_actor_keys(struct port *port, bool reset);
132 
133 
134 /* ================= api to bonding and kernel code ================== */
135 
136 /**
137  * __get_bond_by_port - get the port's bonding struct
138  * @port: the port we're looking at
139  *
140  * Return @port's bonding struct, or %NULL if it can't be found.
141  */
142 static inline struct bonding *__get_bond_by_port(struct port *port)
143 {
144 	if (port->slave == NULL)
145 		return NULL;
146 
147 	return bond_get_bond_by_slave(port->slave);
148 }
149 
150 /**
151  * __get_first_agg - get the first aggregator in the bond
152  * @bond: the bond we're looking at
153  *
154  * Return the aggregator of the first slave in @bond, or %NULL if it can't be
155  * found.
156  * The caller must hold RCU or RTNL lock.
157  */
158 static inline struct aggregator *__get_first_agg(struct port *port)
159 {
160 	struct bonding *bond = __get_bond_by_port(port);
161 	struct slave *first_slave;
162 	struct aggregator *agg;
163 
164 	/* If there's no bond for this port, or bond has no slaves */
165 	if (bond == NULL)
166 		return NULL;
167 
168 	rcu_read_lock();
169 	first_slave = bond_first_slave_rcu(bond);
170 	agg = first_slave ? &(SLAVE_AD_INFO(first_slave)->aggregator) : NULL;
171 	rcu_read_unlock();
172 
173 	return agg;
174 }
175 
176 /**
177  * __agg_has_partner - see if we have a partner
178  * @agg: the agregator we're looking at
179  *
180  * Return nonzero if aggregator has a partner (denoted by a non-zero ether
181  * address for the partner). Return 0 if not.
182  */
183 static inline int __agg_has_partner(struct aggregator *agg)
184 {
185 	return !is_zero_ether_addr(agg->partner_system.mac_addr_value);
186 }
187 
188 /**
189  * __disable_port - disable the port's slave
190  * @port: the port we're looking at
191  */
192 static inline void __disable_port(struct port *port)
193 {
194 	bond_set_slave_inactive_flags(port->slave, BOND_SLAVE_NOTIFY_LATER);
195 }
196 
197 /**
198  * __enable_port - enable the port's slave, if it's up
199  * @port: the port we're looking at
200  */
201 static inline void __enable_port(struct port *port)
202 {
203 	struct slave *slave = port->slave;
204 
205 	if ((slave->link == BOND_LINK_UP) && bond_slave_is_up(slave))
206 		bond_set_slave_active_flags(slave, BOND_SLAVE_NOTIFY_LATER);
207 }
208 
209 /**
210  * __port_is_enabled - check if the port's slave is in active state
211  * @port: the port we're looking at
212  */
213 static inline int __port_is_enabled(struct port *port)
214 {
215 	return bond_is_active_slave(port->slave);
216 }
217 
218 /**
219  * __get_agg_selection_mode - get the aggregator selection mode
220  * @port: the port we're looking at
221  *
222  * Get the aggregator selection mode. Can be %STABLE, %BANDWIDTH or %COUNT.
223  */
224 static inline u32 __get_agg_selection_mode(struct port *port)
225 {
226 	struct bonding *bond = __get_bond_by_port(port);
227 
228 	if (bond == NULL)
229 		return BOND_AD_STABLE;
230 
231 	return bond->params.ad_select;
232 }
233 
234 /**
235  * __check_agg_selection_timer - check if the selection timer has expired
236  * @port: the port we're looking at
237  */
238 static inline int __check_agg_selection_timer(struct port *port)
239 {
240 	struct bonding *bond = __get_bond_by_port(port);
241 
242 	if (bond == NULL)
243 		return 0;
244 
245 	return BOND_AD_INFO(bond).agg_select_timer ? 1 : 0;
246 }
247 
248 /**
249  * __get_link_speed - get a port's speed
250  * @port: the port we're looking at
251  *
252  * Return @port's speed in 802.3ad enum format. i.e. one of:
253  *     0,
254  *     %AD_LINK_SPEED_10MBPS,
255  *     %AD_LINK_SPEED_100MBPS,
256  *     %AD_LINK_SPEED_1000MBPS,
257  *     %AD_LINK_SPEED_2500MBPS,
258  *     %AD_LINK_SPEED_10000MBPS
259  *     %AD_LINK_SPEED_20000MBPS
260  *     %AD_LINK_SPEED_40000MBPS
261  *     %AD_LINK_SPEED_56000MBPS
262  *     %AD_LINK_SPEED_100000MBPS
263  */
264 static u16 __get_link_speed(struct port *port)
265 {
266 	struct slave *slave = port->slave;
267 	u16 speed;
268 
269 	/* this if covers only a special case: when the configuration starts
270 	 * with link down, it sets the speed to 0.
271 	 * This is done in spite of the fact that the e100 driver reports 0
272 	 * to be compatible with MVT in the future.
273 	 */
274 	if (slave->link != BOND_LINK_UP)
275 		speed = 0;
276 	else {
277 		switch (slave->speed) {
278 		case SPEED_10:
279 			speed = AD_LINK_SPEED_10MBPS;
280 			break;
281 
282 		case SPEED_100:
283 			speed = AD_LINK_SPEED_100MBPS;
284 			break;
285 
286 		case SPEED_1000:
287 			speed = AD_LINK_SPEED_1000MBPS;
288 			break;
289 
290 		case SPEED_2500:
291 			speed = AD_LINK_SPEED_2500MBPS;
292 			break;
293 
294 		case SPEED_10000:
295 			speed = AD_LINK_SPEED_10000MBPS;
296 			break;
297 
298 		case SPEED_20000:
299 			speed = AD_LINK_SPEED_20000MBPS;
300 			break;
301 
302 		case SPEED_40000:
303 			speed = AD_LINK_SPEED_40000MBPS;
304 			break;
305 
306 		case SPEED_56000:
307 			speed = AD_LINK_SPEED_56000MBPS;
308 			break;
309 
310 		case SPEED_100000:
311 			speed = AD_LINK_SPEED_100000MBPS;
312 			break;
313 
314 		default:
315 			/* unknown speed value from ethtool. shouldn't happen */
316 			speed = 0;
317 			break;
318 		}
319 	}
320 
321 	netdev_dbg(slave->bond->dev, "Port %d Received link speed %d update from adapter\n",
322 		   port->actor_port_number, speed);
323 	return speed;
324 }
325 
326 /**
327  * __get_duplex - get a port's duplex
328  * @port: the port we're looking at
329  *
330  * Return @port's duplex in 802.3ad bitmask format. i.e.:
331  *     0x01 if in full duplex
332  *     0x00 otherwise
333  */
334 static u8 __get_duplex(struct port *port)
335 {
336 	struct slave *slave = port->slave;
337 	u8 retval = 0x0;
338 
339 	/* handling a special case: when the configuration starts with
340 	 * link down, it sets the duplex to 0.
341 	 */
342 	if (slave->link == BOND_LINK_UP) {
343 		switch (slave->duplex) {
344 		case DUPLEX_FULL:
345 			retval = 0x1;
346 			netdev_dbg(slave->bond->dev, "Port %d Received status full duplex update from adapter\n",
347 				   port->actor_port_number);
348 			break;
349 		case DUPLEX_HALF:
350 		default:
351 			retval = 0x0;
352 			netdev_dbg(slave->bond->dev, "Port %d Received status NOT full duplex update from adapter\n",
353 				   port->actor_port_number);
354 			break;
355 		}
356 	}
357 	return retval;
358 }
359 
360 static void __ad_actor_update_port(struct port *port)
361 {
362 	const struct bonding *bond = bond_get_bond_by_slave(port->slave);
363 
364 	port->actor_system = BOND_AD_INFO(bond).system.sys_mac_addr;
365 	port->actor_system_priority = BOND_AD_INFO(bond).system.sys_priority;
366 }
367 
368 /* Conversions */
369 
370 /**
371  * __ad_timer_to_ticks - convert a given timer type to AD module ticks
372  * @timer_type:	which timer to operate
373  * @par: timer parameter. see below
374  *
375  * If @timer_type is %current_while_timer, @par indicates long/short timer.
376  * If @timer_type is %periodic_timer, @par is one of %FAST_PERIODIC_TIME,
377  *						     %SLOW_PERIODIC_TIME.
378  */
379 static u16 __ad_timer_to_ticks(u16 timer_type, u16 par)
380 {
381 	u16 retval = 0; /* to silence the compiler */
382 
383 	switch (timer_type) {
384 	case AD_CURRENT_WHILE_TIMER:	/* for rx machine usage */
385 		if (par)
386 			retval = (AD_SHORT_TIMEOUT_TIME*ad_ticks_per_sec);
387 		else
388 			retval = (AD_LONG_TIMEOUT_TIME*ad_ticks_per_sec);
389 		break;
390 	case AD_ACTOR_CHURN_TIMER:	/* for local churn machine */
391 		retval = (AD_CHURN_DETECTION_TIME*ad_ticks_per_sec);
392 		break;
393 	case AD_PERIODIC_TIMER:		/* for periodic machine */
394 		retval = (par*ad_ticks_per_sec); /* long timeout */
395 		break;
396 	case AD_PARTNER_CHURN_TIMER:	/* for remote churn machine */
397 		retval = (AD_CHURN_DETECTION_TIME*ad_ticks_per_sec);
398 		break;
399 	case AD_WAIT_WHILE_TIMER:	/* for selection machine */
400 		retval = (AD_AGGREGATE_WAIT_TIME*ad_ticks_per_sec);
401 		break;
402 	}
403 
404 	return retval;
405 }
406 
407 
408 /* ================= ad_rx_machine helper functions ================== */
409 
410 /**
411  * __choose_matched - update a port's matched variable from a received lacpdu
412  * @lacpdu: the lacpdu we've received
413  * @port: the port we're looking at
414  *
415  * Update the value of the matched variable, using parameter values from a
416  * newly received lacpdu. Parameter values for the partner carried in the
417  * received PDU are compared with the corresponding operational parameter
418  * values for the actor. Matched is set to TRUE if all of these parameters
419  * match and the PDU parameter partner_state.aggregation has the same value as
420  * actor_oper_port_state.aggregation and lacp will actively maintain the link
421  * in the aggregation. Matched is also set to TRUE if the value of
422  * actor_state.aggregation in the received PDU is set to FALSE, i.e., indicates
423  * an individual link and lacp will actively maintain the link. Otherwise,
424  * matched is set to FALSE. LACP is considered to be actively maintaining the
425  * link if either the PDU's actor_state.lacp_activity variable is TRUE or both
426  * the actor's actor_oper_port_state.lacp_activity and the PDU's
427  * partner_state.lacp_activity variables are TRUE.
428  *
429  * Note: the AD_PORT_MATCHED "variable" is not specified by 802.3ad; it is
430  * used here to implement the language from 802.3ad 43.4.9 that requires
431  * recordPDU to "match" the LACPDU parameters to the stored values.
432  */
433 static void __choose_matched(struct lacpdu *lacpdu, struct port *port)
434 {
435 	/* check if all parameters are alike
436 	 * or this is individual link(aggregation == FALSE)
437 	 * then update the state machine Matched variable.
438 	 */
439 	if (((ntohs(lacpdu->partner_port) == port->actor_port_number) &&
440 	     (ntohs(lacpdu->partner_port_priority) == port->actor_port_priority) &&
441 	     MAC_ADDRESS_EQUAL(&(lacpdu->partner_system), &(port->actor_system)) &&
442 	     (ntohs(lacpdu->partner_system_priority) == port->actor_system_priority) &&
443 	     (ntohs(lacpdu->partner_key) == port->actor_oper_port_key) &&
444 	     ((lacpdu->partner_state & AD_STATE_AGGREGATION) == (port->actor_oper_port_state & AD_STATE_AGGREGATION))) ||
445 	    ((lacpdu->actor_state & AD_STATE_AGGREGATION) == 0)
446 		) {
447 		port->sm_vars |= AD_PORT_MATCHED;
448 	} else {
449 		port->sm_vars &= ~AD_PORT_MATCHED;
450 	}
451 }
452 
453 /**
454  * __record_pdu - record parameters from a received lacpdu
455  * @lacpdu: the lacpdu we've received
456  * @port: the port we're looking at
457  *
458  * Record the parameter values for the Actor carried in a received lacpdu as
459  * the current partner operational parameter values and sets
460  * actor_oper_port_state.defaulted to FALSE.
461  */
462 static void __record_pdu(struct lacpdu *lacpdu, struct port *port)
463 {
464 	if (lacpdu && port) {
465 		struct port_params *partner = &port->partner_oper;
466 
467 		__choose_matched(lacpdu, port);
468 		/* record the new parameter values for the partner
469 		 * operational
470 		 */
471 		partner->port_number = ntohs(lacpdu->actor_port);
472 		partner->port_priority = ntohs(lacpdu->actor_port_priority);
473 		partner->system = lacpdu->actor_system;
474 		partner->system_priority = ntohs(lacpdu->actor_system_priority);
475 		partner->key = ntohs(lacpdu->actor_key);
476 		partner->port_state = lacpdu->actor_state;
477 
478 		/* set actor_oper_port_state.defaulted to FALSE */
479 		port->actor_oper_port_state &= ~AD_STATE_DEFAULTED;
480 
481 		/* set the partner sync. to on if the partner is sync,
482 		 * and the port is matched
483 		 */
484 		if ((port->sm_vars & AD_PORT_MATCHED) &&
485 		    (lacpdu->actor_state & AD_STATE_SYNCHRONIZATION)) {
486 			partner->port_state |= AD_STATE_SYNCHRONIZATION;
487 			pr_debug("%s partner sync=1\n", port->slave->dev->name);
488 		} else {
489 			partner->port_state &= ~AD_STATE_SYNCHRONIZATION;
490 			pr_debug("%s partner sync=0\n", port->slave->dev->name);
491 		}
492 	}
493 }
494 
495 /**
496  * __record_default - record default parameters
497  * @port: the port we're looking at
498  *
499  * This function records the default parameter values for the partner carried
500  * in the Partner Admin parameters as the current partner operational parameter
501  * values and sets actor_oper_port_state.defaulted to TRUE.
502  */
503 static void __record_default(struct port *port)
504 {
505 	if (port) {
506 		/* record the partner admin parameters */
507 		memcpy(&port->partner_oper, &port->partner_admin,
508 		       sizeof(struct port_params));
509 
510 		/* set actor_oper_port_state.defaulted to true */
511 		port->actor_oper_port_state |= AD_STATE_DEFAULTED;
512 	}
513 }
514 
515 /**
516  * __update_selected - update a port's Selected variable from a received lacpdu
517  * @lacpdu: the lacpdu we've received
518  * @port: the port we're looking at
519  *
520  * Update the value of the selected variable, using parameter values from a
521  * newly received lacpdu. The parameter values for the Actor carried in the
522  * received PDU are compared with the corresponding operational parameter
523  * values for the ports partner. If one or more of the comparisons shows that
524  * the value(s) received in the PDU differ from the current operational values,
525  * then selected is set to FALSE and actor_oper_port_state.synchronization is
526  * set to out_of_sync. Otherwise, selected remains unchanged.
527  */
528 static void __update_selected(struct lacpdu *lacpdu, struct port *port)
529 {
530 	if (lacpdu && port) {
531 		const struct port_params *partner = &port->partner_oper;
532 
533 		/* check if any parameter is different then
534 		 * update the state machine selected variable.
535 		 */
536 		if (ntohs(lacpdu->actor_port) != partner->port_number ||
537 		    ntohs(lacpdu->actor_port_priority) != partner->port_priority ||
538 		    !MAC_ADDRESS_EQUAL(&lacpdu->actor_system, &partner->system) ||
539 		    ntohs(lacpdu->actor_system_priority) != partner->system_priority ||
540 		    ntohs(lacpdu->actor_key) != partner->key ||
541 		    (lacpdu->actor_state & AD_STATE_AGGREGATION) != (partner->port_state & AD_STATE_AGGREGATION)) {
542 			port->sm_vars &= ~AD_PORT_SELECTED;
543 		}
544 	}
545 }
546 
547 /**
548  * __update_default_selected - update a port's Selected variable from Partner
549  * @port: the port we're looking at
550  *
551  * This function updates the value of the selected variable, using the partner
552  * administrative parameter values. The administrative values are compared with
553  * the corresponding operational parameter values for the partner. If one or
554  * more of the comparisons shows that the administrative value(s) differ from
555  * the current operational values, then Selected is set to FALSE and
556  * actor_oper_port_state.synchronization is set to OUT_OF_SYNC. Otherwise,
557  * Selected remains unchanged.
558  */
559 static void __update_default_selected(struct port *port)
560 {
561 	if (port) {
562 		const struct port_params *admin = &port->partner_admin;
563 		const struct port_params *oper = &port->partner_oper;
564 
565 		/* check if any parameter is different then
566 		 * update the state machine selected variable.
567 		 */
568 		if (admin->port_number != oper->port_number ||
569 		    admin->port_priority != oper->port_priority ||
570 		    !MAC_ADDRESS_EQUAL(&admin->system, &oper->system) ||
571 		    admin->system_priority != oper->system_priority ||
572 		    admin->key != oper->key ||
573 		    (admin->port_state & AD_STATE_AGGREGATION)
574 			!= (oper->port_state & AD_STATE_AGGREGATION)) {
575 			port->sm_vars &= ~AD_PORT_SELECTED;
576 		}
577 	}
578 }
579 
580 /**
581  * __update_ntt - update a port's ntt variable from a received lacpdu
582  * @lacpdu: the lacpdu we've received
583  * @port: the port we're looking at
584  *
585  * Updates the value of the ntt variable, using parameter values from a newly
586  * received lacpdu. The parameter values for the partner carried in the
587  * received PDU are compared with the corresponding operational parameter
588  * values for the Actor. If one or more of the comparisons shows that the
589  * value(s) received in the PDU differ from the current operational values,
590  * then ntt is set to TRUE. Otherwise, ntt remains unchanged.
591  */
592 static void __update_ntt(struct lacpdu *lacpdu, struct port *port)
593 {
594 	/* validate lacpdu and port */
595 	if (lacpdu && port) {
596 		/* check if any parameter is different then
597 		 * update the port->ntt.
598 		 */
599 		if ((ntohs(lacpdu->partner_port) != port->actor_port_number) ||
600 		    (ntohs(lacpdu->partner_port_priority) != port->actor_port_priority) ||
601 		    !MAC_ADDRESS_EQUAL(&(lacpdu->partner_system), &(port->actor_system)) ||
602 		    (ntohs(lacpdu->partner_system_priority) != port->actor_system_priority) ||
603 		    (ntohs(lacpdu->partner_key) != port->actor_oper_port_key) ||
604 		    ((lacpdu->partner_state & AD_STATE_LACP_ACTIVITY) != (port->actor_oper_port_state & AD_STATE_LACP_ACTIVITY)) ||
605 		    ((lacpdu->partner_state & AD_STATE_LACP_TIMEOUT) != (port->actor_oper_port_state & AD_STATE_LACP_TIMEOUT)) ||
606 		    ((lacpdu->partner_state & AD_STATE_SYNCHRONIZATION) != (port->actor_oper_port_state & AD_STATE_SYNCHRONIZATION)) ||
607 		    ((lacpdu->partner_state & AD_STATE_AGGREGATION) != (port->actor_oper_port_state & AD_STATE_AGGREGATION))
608 		   ) {
609 			port->ntt = true;
610 		}
611 	}
612 }
613 
614 /**
615  * __agg_ports_are_ready - check if all ports in an aggregator are ready
616  * @aggregator: the aggregator we're looking at
617  *
618  */
619 static int __agg_ports_are_ready(struct aggregator *aggregator)
620 {
621 	struct port *port;
622 	int retval = 1;
623 
624 	if (aggregator) {
625 		/* scan all ports in this aggregator to verfy if they are
626 		 * all ready.
627 		 */
628 		for (port = aggregator->lag_ports;
629 		     port;
630 		     port = port->next_port_in_aggregator) {
631 			if (!(port->sm_vars & AD_PORT_READY_N)) {
632 				retval = 0;
633 				break;
634 			}
635 		}
636 	}
637 
638 	return retval;
639 }
640 
641 /**
642  * __set_agg_ports_ready - set value of Ready bit in all ports of an aggregator
643  * @aggregator: the aggregator we're looking at
644  * @val: Should the ports' ready bit be set on or off
645  *
646  */
647 static void __set_agg_ports_ready(struct aggregator *aggregator, int val)
648 {
649 	struct port *port;
650 
651 	for (port = aggregator->lag_ports; port;
652 	     port = port->next_port_in_aggregator) {
653 		if (val)
654 			port->sm_vars |= AD_PORT_READY;
655 		else
656 			port->sm_vars &= ~AD_PORT_READY;
657 	}
658 }
659 
660 /**
661  * __get_agg_bandwidth - get the total bandwidth of an aggregator
662  * @aggregator: the aggregator we're looking at
663  *
664  */
665 static u32 __get_agg_bandwidth(struct aggregator *aggregator)
666 {
667 	u32 bandwidth = 0;
668 
669 	if (aggregator->num_of_ports) {
670 		switch (__get_link_speed(aggregator->lag_ports)) {
671 		case AD_LINK_SPEED_1MBPS:
672 			bandwidth = aggregator->num_of_ports;
673 			break;
674 		case AD_LINK_SPEED_10MBPS:
675 			bandwidth = aggregator->num_of_ports * 10;
676 			break;
677 		case AD_LINK_SPEED_100MBPS:
678 			bandwidth = aggregator->num_of_ports * 100;
679 			break;
680 		case AD_LINK_SPEED_1000MBPS:
681 			bandwidth = aggregator->num_of_ports * 1000;
682 			break;
683 		case AD_LINK_SPEED_2500MBPS:
684 			bandwidth = aggregator->num_of_ports * 2500;
685 			break;
686 		case AD_LINK_SPEED_10000MBPS:
687 			bandwidth = aggregator->num_of_ports * 10000;
688 			break;
689 		case AD_LINK_SPEED_20000MBPS:
690 			bandwidth = aggregator->num_of_ports * 20000;
691 			break;
692 		case AD_LINK_SPEED_40000MBPS:
693 			bandwidth = aggregator->num_of_ports * 40000;
694 			break;
695 		case AD_LINK_SPEED_56000MBPS:
696 			bandwidth = aggregator->num_of_ports * 56000;
697 			break;
698 		case AD_LINK_SPEED_100000MBPS:
699 			bandwidth = aggregator->num_of_ports * 100000;
700 			break;
701 		default:
702 			bandwidth = 0; /* to silence the compiler */
703 		}
704 	}
705 	return bandwidth;
706 }
707 
708 /**
709  * __get_active_agg - get the current active aggregator
710  * @aggregator: the aggregator we're looking at
711  *
712  * Caller must hold RCU lock.
713  */
714 static struct aggregator *__get_active_agg(struct aggregator *aggregator)
715 {
716 	struct bonding *bond = aggregator->slave->bond;
717 	struct list_head *iter;
718 	struct slave *slave;
719 
720 	bond_for_each_slave_rcu(bond, slave, iter)
721 		if (SLAVE_AD_INFO(slave)->aggregator.is_active)
722 			return &(SLAVE_AD_INFO(slave)->aggregator);
723 
724 	return NULL;
725 }
726 
727 /**
728  * __update_lacpdu_from_port - update a port's lacpdu fields
729  * @port: the port we're looking at
730  */
731 static inline void __update_lacpdu_from_port(struct port *port)
732 {
733 	struct lacpdu *lacpdu = &port->lacpdu;
734 	const struct port_params *partner = &port->partner_oper;
735 
736 	/* update current actual Actor parameters
737 	 * lacpdu->subtype                   initialized
738 	 * lacpdu->version_number            initialized
739 	 * lacpdu->tlv_type_actor_info       initialized
740 	 * lacpdu->actor_information_length  initialized
741 	 */
742 
743 	lacpdu->actor_system_priority = htons(port->actor_system_priority);
744 	lacpdu->actor_system = port->actor_system;
745 	lacpdu->actor_key = htons(port->actor_oper_port_key);
746 	lacpdu->actor_port_priority = htons(port->actor_port_priority);
747 	lacpdu->actor_port = htons(port->actor_port_number);
748 	lacpdu->actor_state = port->actor_oper_port_state;
749 	pr_debug("update lacpdu: %s, actor port state %x\n",
750 		 port->slave->dev->name, port->actor_oper_port_state);
751 
752 	/* lacpdu->reserved_3_1              initialized
753 	 * lacpdu->tlv_type_partner_info     initialized
754 	 * lacpdu->partner_information_length initialized
755 	 */
756 
757 	lacpdu->partner_system_priority = htons(partner->system_priority);
758 	lacpdu->partner_system = partner->system;
759 	lacpdu->partner_key = htons(partner->key);
760 	lacpdu->partner_port_priority = htons(partner->port_priority);
761 	lacpdu->partner_port = htons(partner->port_number);
762 	lacpdu->partner_state = partner->port_state;
763 
764 	/* lacpdu->reserved_3_2              initialized
765 	 * lacpdu->tlv_type_collector_info   initialized
766 	 * lacpdu->collector_information_length initialized
767 	 * collector_max_delay                initialized
768 	 * reserved_12[12]                   initialized
769 	 * tlv_type_terminator               initialized
770 	 * terminator_length                 initialized
771 	 * reserved_50[50]                   initialized
772 	 */
773 }
774 
775 /* ================= main 802.3ad protocol code ========================= */
776 
777 /**
778  * ad_lacpdu_send - send out a lacpdu packet on a given port
779  * @port: the port we're looking at
780  *
781  * Returns:   0 on success
782  *          < 0 on error
783  */
784 static int ad_lacpdu_send(struct port *port)
785 {
786 	struct slave *slave = port->slave;
787 	struct sk_buff *skb;
788 	struct lacpdu_header *lacpdu_header;
789 	int length = sizeof(struct lacpdu_header);
790 
791 	skb = dev_alloc_skb(length);
792 	if (!skb)
793 		return -ENOMEM;
794 
795 	skb->dev = slave->dev;
796 	skb_reset_mac_header(skb);
797 	skb->network_header = skb->mac_header + ETH_HLEN;
798 	skb->protocol = PKT_TYPE_LACPDU;
799 	skb->priority = TC_PRIO_CONTROL;
800 
801 	lacpdu_header = (struct lacpdu_header *)skb_put(skb, length);
802 
803 	ether_addr_copy(lacpdu_header->hdr.h_dest, lacpdu_mcast_addr);
804 	/* Note: source address is set to be the member's PERMANENT address,
805 	 * because we use it to identify loopback lacpdus in receive.
806 	 */
807 	ether_addr_copy(lacpdu_header->hdr.h_source, slave->perm_hwaddr);
808 	lacpdu_header->hdr.h_proto = PKT_TYPE_LACPDU;
809 
810 	lacpdu_header->lacpdu = port->lacpdu;
811 
812 	dev_queue_xmit(skb);
813 
814 	return 0;
815 }
816 
817 /**
818  * ad_marker_send - send marker information/response on a given port
819  * @port: the port we're looking at
820  * @marker: marker data to send
821  *
822  * Returns:   0 on success
823  *          < 0 on error
824  */
825 static int ad_marker_send(struct port *port, struct bond_marker *marker)
826 {
827 	struct slave *slave = port->slave;
828 	struct sk_buff *skb;
829 	struct bond_marker_header *marker_header;
830 	int length = sizeof(struct bond_marker_header);
831 
832 	skb = dev_alloc_skb(length + 16);
833 	if (!skb)
834 		return -ENOMEM;
835 
836 	skb_reserve(skb, 16);
837 
838 	skb->dev = slave->dev;
839 	skb_reset_mac_header(skb);
840 	skb->network_header = skb->mac_header + ETH_HLEN;
841 	skb->protocol = PKT_TYPE_LACPDU;
842 
843 	marker_header = (struct bond_marker_header *)skb_put(skb, length);
844 
845 	ether_addr_copy(marker_header->hdr.h_dest, lacpdu_mcast_addr);
846 	/* Note: source address is set to be the member's PERMANENT address,
847 	 * because we use it to identify loopback MARKERs in receive.
848 	 */
849 	ether_addr_copy(marker_header->hdr.h_source, slave->perm_hwaddr);
850 	marker_header->hdr.h_proto = PKT_TYPE_LACPDU;
851 
852 	marker_header->marker = *marker;
853 
854 	dev_queue_xmit(skb);
855 
856 	return 0;
857 }
858 
859 /**
860  * ad_mux_machine - handle a port's mux state machine
861  * @port: the port we're looking at
862  * @update_slave_arr: Does slave array need update?
863  */
864 static void ad_mux_machine(struct port *port, bool *update_slave_arr)
865 {
866 	mux_states_t last_state;
867 
868 	/* keep current State Machine state to compare later if it was
869 	 * changed
870 	 */
871 	last_state = port->sm_mux_state;
872 
873 	if (port->sm_vars & AD_PORT_BEGIN) {
874 		port->sm_mux_state = AD_MUX_DETACHED;
875 	} else {
876 		switch (port->sm_mux_state) {
877 		case AD_MUX_DETACHED:
878 			if ((port->sm_vars & AD_PORT_SELECTED)
879 			    || (port->sm_vars & AD_PORT_STANDBY))
880 				/* if SELECTED or STANDBY */
881 				port->sm_mux_state = AD_MUX_WAITING;
882 			break;
883 		case AD_MUX_WAITING:
884 			/* if SELECTED == FALSE return to DETACH state */
885 			if (!(port->sm_vars & AD_PORT_SELECTED)) {
886 				port->sm_vars &= ~AD_PORT_READY_N;
887 				/* in order to withhold the Selection Logic to
888 				 * check all ports READY_N value every callback
889 				 * cycle to update ready variable, we check
890 				 * READY_N and update READY here
891 				 */
892 				__set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
893 				port->sm_mux_state = AD_MUX_DETACHED;
894 				break;
895 			}
896 
897 			/* check if the wait_while_timer expired */
898 			if (port->sm_mux_timer_counter
899 			    && !(--port->sm_mux_timer_counter))
900 				port->sm_vars |= AD_PORT_READY_N;
901 
902 			/* in order to withhold the selection logic to check
903 			 * all ports READY_N value every callback cycle to
904 			 * update ready variable, we check READY_N and update
905 			 * READY here
906 			 */
907 			__set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
908 
909 			/* if the wait_while_timer expired, and the port is
910 			 * in READY state, move to ATTACHED state
911 			 */
912 			if ((port->sm_vars & AD_PORT_READY)
913 			    && !port->sm_mux_timer_counter)
914 				port->sm_mux_state = AD_MUX_ATTACHED;
915 			break;
916 		case AD_MUX_ATTACHED:
917 			/* check also if agg_select_timer expired (so the
918 			 * edable port will take place only after this timer)
919 			 */
920 			if ((port->sm_vars & AD_PORT_SELECTED) &&
921 			    (port->partner_oper.port_state & AD_STATE_SYNCHRONIZATION) &&
922 			    !__check_agg_selection_timer(port)) {
923 				if (port->aggregator->is_active)
924 					port->sm_mux_state =
925 					    AD_MUX_COLLECTING_DISTRIBUTING;
926 			} else if (!(port->sm_vars & AD_PORT_SELECTED) ||
927 				   (port->sm_vars & AD_PORT_STANDBY)) {
928 				/* if UNSELECTED or STANDBY */
929 				port->sm_vars &= ~AD_PORT_READY_N;
930 				/* in order to withhold the selection logic to
931 				 * check all ports READY_N value every callback
932 				 * cycle to update ready variable, we check
933 				 * READY_N and update READY here
934 				 */
935 				__set_agg_ports_ready(port->aggregator, __agg_ports_are_ready(port->aggregator));
936 				port->sm_mux_state = AD_MUX_DETACHED;
937 			} else if (port->aggregator->is_active) {
938 				port->actor_oper_port_state |=
939 				    AD_STATE_SYNCHRONIZATION;
940 			}
941 			break;
942 		case AD_MUX_COLLECTING_DISTRIBUTING:
943 			if (!(port->sm_vars & AD_PORT_SELECTED) ||
944 			    (port->sm_vars & AD_PORT_STANDBY) ||
945 			    !(port->partner_oper.port_state & AD_STATE_SYNCHRONIZATION) ||
946 			    !(port->actor_oper_port_state & AD_STATE_SYNCHRONIZATION)) {
947 				port->sm_mux_state = AD_MUX_ATTACHED;
948 			} else {
949 				/* if port state hasn't changed make
950 				 * sure that a collecting distributing
951 				 * port in an active aggregator is enabled
952 				 */
953 				if (port->aggregator &&
954 				    port->aggregator->is_active &&
955 				    !__port_is_enabled(port)) {
956 
957 					__enable_port(port);
958 				}
959 			}
960 			break;
961 		default:
962 			break;
963 		}
964 	}
965 
966 	/* check if the state machine was changed */
967 	if (port->sm_mux_state != last_state) {
968 		pr_debug("Mux Machine: Port=%d (%s), Last State=%d, Curr State=%d\n",
969 			 port->actor_port_number,
970 			 port->slave->dev->name,
971 			 last_state,
972 			 port->sm_mux_state);
973 		switch (port->sm_mux_state) {
974 		case AD_MUX_DETACHED:
975 			port->actor_oper_port_state &= ~AD_STATE_SYNCHRONIZATION;
976 			ad_disable_collecting_distributing(port,
977 							   update_slave_arr);
978 			port->actor_oper_port_state &= ~AD_STATE_COLLECTING;
979 			port->actor_oper_port_state &= ~AD_STATE_DISTRIBUTING;
980 			port->ntt = true;
981 			break;
982 		case AD_MUX_WAITING:
983 			port->sm_mux_timer_counter = __ad_timer_to_ticks(AD_WAIT_WHILE_TIMER, 0);
984 			break;
985 		case AD_MUX_ATTACHED:
986 			if (port->aggregator->is_active)
987 				port->actor_oper_port_state |=
988 				    AD_STATE_SYNCHRONIZATION;
989 			else
990 				port->actor_oper_port_state &=
991 				    ~AD_STATE_SYNCHRONIZATION;
992 			port->actor_oper_port_state &= ~AD_STATE_COLLECTING;
993 			port->actor_oper_port_state &= ~AD_STATE_DISTRIBUTING;
994 			ad_disable_collecting_distributing(port,
995 							   update_slave_arr);
996 			port->ntt = true;
997 			break;
998 		case AD_MUX_COLLECTING_DISTRIBUTING:
999 			port->actor_oper_port_state |= AD_STATE_COLLECTING;
1000 			port->actor_oper_port_state |= AD_STATE_DISTRIBUTING;
1001 			port->actor_oper_port_state |= AD_STATE_SYNCHRONIZATION;
1002 			ad_enable_collecting_distributing(port,
1003 							  update_slave_arr);
1004 			port->ntt = true;
1005 			break;
1006 		default:
1007 			break;
1008 		}
1009 	}
1010 }
1011 
1012 /**
1013  * ad_rx_machine - handle a port's rx State Machine
1014  * @lacpdu: the lacpdu we've received
1015  * @port: the port we're looking at
1016  *
1017  * If lacpdu arrived, stop previous timer (if exists) and set the next state as
1018  * CURRENT. If timer expired set the state machine in the proper state.
1019  * In other cases, this function checks if we need to switch to other state.
1020  */
1021 static void ad_rx_machine(struct lacpdu *lacpdu, struct port *port)
1022 {
1023 	rx_states_t last_state;
1024 
1025 	/* keep current State Machine state to compare later if it was
1026 	 * changed
1027 	 */
1028 	last_state = port->sm_rx_state;
1029 
1030 	/* check if state machine should change state */
1031 
1032 	/* first, check if port was reinitialized */
1033 	if (port->sm_vars & AD_PORT_BEGIN) {
1034 		port->sm_rx_state = AD_RX_INITIALIZE;
1035 		port->sm_vars |= AD_PORT_CHURNED;
1036 	/* check if port is not enabled */
1037 	} else if (!(port->sm_vars & AD_PORT_BEGIN)
1038 		 && !port->is_enabled && !(port->sm_vars & AD_PORT_MOVED))
1039 		port->sm_rx_state = AD_RX_PORT_DISABLED;
1040 	/* check if new lacpdu arrived */
1041 	else if (lacpdu && ((port->sm_rx_state == AD_RX_EXPIRED) ||
1042 		 (port->sm_rx_state == AD_RX_DEFAULTED) ||
1043 		 (port->sm_rx_state == AD_RX_CURRENT))) {
1044 		if (port->sm_rx_state != AD_RX_CURRENT)
1045 			port->sm_vars |= AD_PORT_CHURNED;
1046 		port->sm_rx_timer_counter = 0;
1047 		port->sm_rx_state = AD_RX_CURRENT;
1048 	} else {
1049 		/* if timer is on, and if it is expired */
1050 		if (port->sm_rx_timer_counter &&
1051 		    !(--port->sm_rx_timer_counter)) {
1052 			switch (port->sm_rx_state) {
1053 			case AD_RX_EXPIRED:
1054 				port->sm_rx_state = AD_RX_DEFAULTED;
1055 				break;
1056 			case AD_RX_CURRENT:
1057 				port->sm_rx_state = AD_RX_EXPIRED;
1058 				break;
1059 			default:
1060 				break;
1061 			}
1062 		} else {
1063 			/* if no lacpdu arrived and no timer is on */
1064 			switch (port->sm_rx_state) {
1065 			case AD_RX_PORT_DISABLED:
1066 				if (port->sm_vars & AD_PORT_MOVED)
1067 					port->sm_rx_state = AD_RX_INITIALIZE;
1068 				else if (port->is_enabled
1069 					 && (port->sm_vars
1070 					     & AD_PORT_LACP_ENABLED))
1071 					port->sm_rx_state = AD_RX_EXPIRED;
1072 				else if (port->is_enabled
1073 					 && ((port->sm_vars
1074 					      & AD_PORT_LACP_ENABLED) == 0))
1075 					port->sm_rx_state = AD_RX_LACP_DISABLED;
1076 				break;
1077 			default:
1078 				break;
1079 
1080 			}
1081 		}
1082 	}
1083 
1084 	/* check if the State machine was changed or new lacpdu arrived */
1085 	if ((port->sm_rx_state != last_state) || (lacpdu)) {
1086 		pr_debug("Rx Machine: Port=%d (%s), Last State=%d, Curr State=%d\n",
1087 			 port->actor_port_number,
1088 			 port->slave->dev->name,
1089 			 last_state,
1090 			 port->sm_rx_state);
1091 		switch (port->sm_rx_state) {
1092 		case AD_RX_INITIALIZE:
1093 			if (!(port->actor_oper_port_key & AD_DUPLEX_KEY_MASKS))
1094 				port->sm_vars &= ~AD_PORT_LACP_ENABLED;
1095 			else
1096 				port->sm_vars |= AD_PORT_LACP_ENABLED;
1097 			port->sm_vars &= ~AD_PORT_SELECTED;
1098 			__record_default(port);
1099 			port->actor_oper_port_state &= ~AD_STATE_EXPIRED;
1100 			port->sm_vars &= ~AD_PORT_MOVED;
1101 			port->sm_rx_state = AD_RX_PORT_DISABLED;
1102 
1103 			/* Fall Through */
1104 		case AD_RX_PORT_DISABLED:
1105 			port->sm_vars &= ~AD_PORT_MATCHED;
1106 			break;
1107 		case AD_RX_LACP_DISABLED:
1108 			port->sm_vars &= ~AD_PORT_SELECTED;
1109 			__record_default(port);
1110 			port->partner_oper.port_state &= ~AD_STATE_AGGREGATION;
1111 			port->sm_vars |= AD_PORT_MATCHED;
1112 			port->actor_oper_port_state &= ~AD_STATE_EXPIRED;
1113 			break;
1114 		case AD_RX_EXPIRED:
1115 			/* Reset of the Synchronization flag (Standard 43.4.12)
1116 			 * This reset cause to disable this port in the
1117 			 * COLLECTING_DISTRIBUTING state of the mux machine in
1118 			 * case of EXPIRED even if LINK_DOWN didn't arrive for
1119 			 * the port.
1120 			 */
1121 			port->partner_oper.port_state &= ~AD_STATE_SYNCHRONIZATION;
1122 			port->sm_vars &= ~AD_PORT_MATCHED;
1123 			port->partner_oper.port_state |= AD_STATE_LACP_TIMEOUT;
1124 			port->partner_oper.port_state |= AD_STATE_LACP_ACTIVITY;
1125 			port->sm_rx_timer_counter = __ad_timer_to_ticks(AD_CURRENT_WHILE_TIMER, (u16)(AD_SHORT_TIMEOUT));
1126 			port->actor_oper_port_state |= AD_STATE_EXPIRED;
1127 			port->sm_vars |= AD_PORT_CHURNED;
1128 			break;
1129 		case AD_RX_DEFAULTED:
1130 			__update_default_selected(port);
1131 			__record_default(port);
1132 			port->sm_vars |= AD_PORT_MATCHED;
1133 			port->actor_oper_port_state &= ~AD_STATE_EXPIRED;
1134 			break;
1135 		case AD_RX_CURRENT:
1136 			/* detect loopback situation */
1137 			if (MAC_ADDRESS_EQUAL(&(lacpdu->actor_system),
1138 					      &(port->actor_system))) {
1139 				netdev_err(port->slave->bond->dev, "An illegal loopback occurred on adapter (%s)\n"
1140 				       "Check the configuration to verify that all adapters are connected to 802.3ad compliant switch ports\n",
1141 				       port->slave->dev->name);
1142 				return;
1143 			}
1144 			__update_selected(lacpdu, port);
1145 			__update_ntt(lacpdu, port);
1146 			__record_pdu(lacpdu, port);
1147 			port->sm_rx_timer_counter = __ad_timer_to_ticks(AD_CURRENT_WHILE_TIMER, (u16)(port->actor_oper_port_state & AD_STATE_LACP_TIMEOUT));
1148 			port->actor_oper_port_state &= ~AD_STATE_EXPIRED;
1149 			break;
1150 		default:
1151 			break;
1152 		}
1153 	}
1154 }
1155 
1156 /**
1157  * ad_churn_machine - handle port churn's state machine
1158  * @port: the port we're looking at
1159  *
1160  */
1161 static void ad_churn_machine(struct port *port)
1162 {
1163 	if (port->sm_vars & AD_PORT_CHURNED) {
1164 		port->sm_vars &= ~AD_PORT_CHURNED;
1165 		port->sm_churn_actor_state = AD_CHURN_MONITOR;
1166 		port->sm_churn_partner_state = AD_CHURN_MONITOR;
1167 		port->sm_churn_actor_timer_counter =
1168 			__ad_timer_to_ticks(AD_ACTOR_CHURN_TIMER, 0);
1169 		 port->sm_churn_partner_timer_counter =
1170 			 __ad_timer_to_ticks(AD_PARTNER_CHURN_TIMER, 0);
1171 		return;
1172 	}
1173 	if (port->sm_churn_actor_timer_counter &&
1174 	    !(--port->sm_churn_actor_timer_counter) &&
1175 	    port->sm_churn_actor_state == AD_CHURN_MONITOR) {
1176 		if (port->actor_oper_port_state & AD_STATE_SYNCHRONIZATION) {
1177 			port->sm_churn_actor_state = AD_NO_CHURN;
1178 		} else {
1179 			port->churn_actor_count++;
1180 			port->sm_churn_actor_state = AD_CHURN;
1181 		}
1182 	}
1183 	if (port->sm_churn_partner_timer_counter &&
1184 	    !(--port->sm_churn_partner_timer_counter) &&
1185 	    port->sm_churn_partner_state == AD_CHURN_MONITOR) {
1186 		if (port->partner_oper.port_state & AD_STATE_SYNCHRONIZATION) {
1187 			port->sm_churn_partner_state = AD_NO_CHURN;
1188 		} else {
1189 			port->churn_partner_count++;
1190 			port->sm_churn_partner_state = AD_CHURN;
1191 		}
1192 	}
1193 }
1194 
1195 /**
1196  * ad_tx_machine - handle a port's tx state machine
1197  * @port: the port we're looking at
1198  */
1199 static void ad_tx_machine(struct port *port)
1200 {
1201 	/* check if tx timer expired, to verify that we do not send more than
1202 	 * 3 packets per second
1203 	 */
1204 	if (port->sm_tx_timer_counter && !(--port->sm_tx_timer_counter)) {
1205 		/* check if there is something to send */
1206 		if (port->ntt && (port->sm_vars & AD_PORT_LACP_ENABLED)) {
1207 			__update_lacpdu_from_port(port);
1208 
1209 			if (ad_lacpdu_send(port) >= 0) {
1210 				pr_debug("Sent LACPDU on port %d\n",
1211 					 port->actor_port_number);
1212 
1213 				/* mark ntt as false, so it will not be sent
1214 				 * again until demanded
1215 				 */
1216 				port->ntt = false;
1217 			}
1218 		}
1219 		/* restart tx timer(to verify that we will not exceed
1220 		 * AD_MAX_TX_IN_SECOND
1221 		 */
1222 		port->sm_tx_timer_counter = ad_ticks_per_sec/AD_MAX_TX_IN_SECOND;
1223 	}
1224 }
1225 
1226 /**
1227  * ad_periodic_machine - handle a port's periodic state machine
1228  * @port: the port we're looking at
1229  *
1230  * Turn ntt flag on priodically to perform periodic transmission of lacpdu's.
1231  */
1232 static void ad_periodic_machine(struct port *port)
1233 {
1234 	periodic_states_t last_state;
1235 
1236 	/* keep current state machine state to compare later if it was changed */
1237 	last_state = port->sm_periodic_state;
1238 
1239 	/* check if port was reinitialized */
1240 	if (((port->sm_vars & AD_PORT_BEGIN) || !(port->sm_vars & AD_PORT_LACP_ENABLED) || !port->is_enabled) ||
1241 	    (!(port->actor_oper_port_state & AD_STATE_LACP_ACTIVITY) && !(port->partner_oper.port_state & AD_STATE_LACP_ACTIVITY))
1242 	   ) {
1243 		port->sm_periodic_state = AD_NO_PERIODIC;
1244 	}
1245 	/* check if state machine should change state */
1246 	else if (port->sm_periodic_timer_counter) {
1247 		/* check if periodic state machine expired */
1248 		if (!(--port->sm_periodic_timer_counter)) {
1249 			/* if expired then do tx */
1250 			port->sm_periodic_state = AD_PERIODIC_TX;
1251 		} else {
1252 			/* If not expired, check if there is some new timeout
1253 			 * parameter from the partner state
1254 			 */
1255 			switch (port->sm_periodic_state) {
1256 			case AD_FAST_PERIODIC:
1257 				if (!(port->partner_oper.port_state
1258 				      & AD_STATE_LACP_TIMEOUT))
1259 					port->sm_periodic_state = AD_SLOW_PERIODIC;
1260 				break;
1261 			case AD_SLOW_PERIODIC:
1262 				if ((port->partner_oper.port_state & AD_STATE_LACP_TIMEOUT)) {
1263 					port->sm_periodic_timer_counter = 0;
1264 					port->sm_periodic_state = AD_PERIODIC_TX;
1265 				}
1266 				break;
1267 			default:
1268 				break;
1269 			}
1270 		}
1271 	} else {
1272 		switch (port->sm_periodic_state) {
1273 		case AD_NO_PERIODIC:
1274 			port->sm_periodic_state = AD_FAST_PERIODIC;
1275 			break;
1276 		case AD_PERIODIC_TX:
1277 			if (!(port->partner_oper.port_state &
1278 			    AD_STATE_LACP_TIMEOUT))
1279 				port->sm_periodic_state = AD_SLOW_PERIODIC;
1280 			else
1281 				port->sm_periodic_state = AD_FAST_PERIODIC;
1282 			break;
1283 		default:
1284 			break;
1285 		}
1286 	}
1287 
1288 	/* check if the state machine was changed */
1289 	if (port->sm_periodic_state != last_state) {
1290 		pr_debug("Periodic Machine: Port=%d, Last State=%d, Curr State=%d\n",
1291 			 port->actor_port_number, last_state,
1292 			 port->sm_periodic_state);
1293 		switch (port->sm_periodic_state) {
1294 		case AD_NO_PERIODIC:
1295 			port->sm_periodic_timer_counter = 0;
1296 			break;
1297 		case AD_FAST_PERIODIC:
1298 			/* decrement 1 tick we lost in the PERIODIC_TX cycle */
1299 			port->sm_periodic_timer_counter = __ad_timer_to_ticks(AD_PERIODIC_TIMER, (u16)(AD_FAST_PERIODIC_TIME))-1;
1300 			break;
1301 		case AD_SLOW_PERIODIC:
1302 			/* decrement 1 tick we lost in the PERIODIC_TX cycle */
1303 			port->sm_periodic_timer_counter = __ad_timer_to_ticks(AD_PERIODIC_TIMER, (u16)(AD_SLOW_PERIODIC_TIME))-1;
1304 			break;
1305 		case AD_PERIODIC_TX:
1306 			port->ntt = true;
1307 			break;
1308 		default:
1309 			break;
1310 		}
1311 	}
1312 }
1313 
1314 /**
1315  * ad_port_selection_logic - select aggregation groups
1316  * @port: the port we're looking at
1317  * @update_slave_arr: Does slave array need update?
1318  *
1319  * Select aggregation groups, and assign each port for it's aggregetor. The
1320  * selection logic is called in the inititalization (after all the handshkes),
1321  * and after every lacpdu receive (if selected is off).
1322  */
1323 static void ad_port_selection_logic(struct port *port, bool *update_slave_arr)
1324 {
1325 	struct aggregator *aggregator, *free_aggregator = NULL, *temp_aggregator;
1326 	struct port *last_port = NULL, *curr_port;
1327 	struct list_head *iter;
1328 	struct bonding *bond;
1329 	struct slave *slave;
1330 	int found = 0;
1331 
1332 	/* if the port is already Selected, do nothing */
1333 	if (port->sm_vars & AD_PORT_SELECTED)
1334 		return;
1335 
1336 	bond = __get_bond_by_port(port);
1337 
1338 	/* if the port is connected to other aggregator, detach it */
1339 	if (port->aggregator) {
1340 		/* detach the port from its former aggregator */
1341 		temp_aggregator = port->aggregator;
1342 		for (curr_port = temp_aggregator->lag_ports; curr_port;
1343 		     last_port = curr_port,
1344 		     curr_port = curr_port->next_port_in_aggregator) {
1345 			if (curr_port == port) {
1346 				temp_aggregator->num_of_ports--;
1347 				/* if it is the first port attached to the
1348 				 * aggregator
1349 				 */
1350 				if (!last_port) {
1351 					temp_aggregator->lag_ports =
1352 						port->next_port_in_aggregator;
1353 				} else {
1354 					/* not the first port attached to the
1355 					 * aggregator
1356 					 */
1357 					last_port->next_port_in_aggregator =
1358 						port->next_port_in_aggregator;
1359 				}
1360 
1361 				/* clear the port's relations to this
1362 				 * aggregator
1363 				 */
1364 				port->aggregator = NULL;
1365 				port->next_port_in_aggregator = NULL;
1366 				port->actor_port_aggregator_identifier = 0;
1367 
1368 				netdev_dbg(bond->dev, "Port %d left LAG %d\n",
1369 					   port->actor_port_number,
1370 					   temp_aggregator->aggregator_identifier);
1371 				/* if the aggregator is empty, clear its
1372 				 * parameters, and set it ready to be attached
1373 				 */
1374 				if (!temp_aggregator->lag_ports)
1375 					ad_clear_agg(temp_aggregator);
1376 				break;
1377 			}
1378 		}
1379 		if (!curr_port) {
1380 			/* meaning: the port was related to an aggregator
1381 			 * but was not on the aggregator port list
1382 			 */
1383 			net_warn_ratelimited("%s: Warning: Port %d (on %s) was related to aggregator %d but was not on its port list\n",
1384 					     port->slave->bond->dev->name,
1385 					     port->actor_port_number,
1386 					     port->slave->dev->name,
1387 					     port->aggregator->aggregator_identifier);
1388 		}
1389 	}
1390 	/* search on all aggregators for a suitable aggregator for this port */
1391 	bond_for_each_slave(bond, slave, iter) {
1392 		aggregator = &(SLAVE_AD_INFO(slave)->aggregator);
1393 
1394 		/* keep a free aggregator for later use(if needed) */
1395 		if (!aggregator->lag_ports) {
1396 			if (!free_aggregator)
1397 				free_aggregator = aggregator;
1398 			continue;
1399 		}
1400 		/* check if current aggregator suits us */
1401 		if (((aggregator->actor_oper_aggregator_key == port->actor_oper_port_key) && /* if all parameters match AND */
1402 		     MAC_ADDRESS_EQUAL(&(aggregator->partner_system), &(port->partner_oper.system)) &&
1403 		     (aggregator->partner_system_priority == port->partner_oper.system_priority) &&
1404 		     (aggregator->partner_oper_aggregator_key == port->partner_oper.key)
1405 		    ) &&
1406 		    ((!MAC_ADDRESS_EQUAL(&(port->partner_oper.system), &(null_mac_addr)) && /* partner answers */
1407 		      !aggregator->is_individual)  /* but is not individual OR */
1408 		    )
1409 		   ) {
1410 			/* attach to the founded aggregator */
1411 			port->aggregator = aggregator;
1412 			port->actor_port_aggregator_identifier =
1413 				port->aggregator->aggregator_identifier;
1414 			port->next_port_in_aggregator = aggregator->lag_ports;
1415 			port->aggregator->num_of_ports++;
1416 			aggregator->lag_ports = port;
1417 			netdev_dbg(bond->dev, "Port %d joined LAG %d(existing LAG)\n",
1418 				   port->actor_port_number,
1419 				   port->aggregator->aggregator_identifier);
1420 
1421 			/* mark this port as selected */
1422 			port->sm_vars |= AD_PORT_SELECTED;
1423 			found = 1;
1424 			break;
1425 		}
1426 	}
1427 
1428 	/* the port couldn't find an aggregator - attach it to a new
1429 	 * aggregator
1430 	 */
1431 	if (!found) {
1432 		if (free_aggregator) {
1433 			/* assign port a new aggregator */
1434 			port->aggregator = free_aggregator;
1435 			port->actor_port_aggregator_identifier =
1436 				port->aggregator->aggregator_identifier;
1437 
1438 			/* update the new aggregator's parameters
1439 			 * if port was responsed from the end-user
1440 			 */
1441 			if (port->actor_oper_port_key & AD_DUPLEX_KEY_MASKS)
1442 				/* if port is full duplex */
1443 				port->aggregator->is_individual = false;
1444 			else
1445 				port->aggregator->is_individual = true;
1446 
1447 			port->aggregator->actor_admin_aggregator_key =
1448 				port->actor_admin_port_key;
1449 			port->aggregator->actor_oper_aggregator_key =
1450 				port->actor_oper_port_key;
1451 			port->aggregator->partner_system =
1452 				port->partner_oper.system;
1453 			port->aggregator->partner_system_priority =
1454 				port->partner_oper.system_priority;
1455 			port->aggregator->partner_oper_aggregator_key = port->partner_oper.key;
1456 			port->aggregator->receive_state = 1;
1457 			port->aggregator->transmit_state = 1;
1458 			port->aggregator->lag_ports = port;
1459 			port->aggregator->num_of_ports++;
1460 
1461 			/* mark this port as selected */
1462 			port->sm_vars |= AD_PORT_SELECTED;
1463 
1464 			netdev_dbg(bond->dev, "Port %d joined LAG %d(new LAG)\n",
1465 				   port->actor_port_number,
1466 				   port->aggregator->aggregator_identifier);
1467 		} else {
1468 			netdev_err(bond->dev, "Port %d (on %s) did not find a suitable aggregator\n",
1469 			       port->actor_port_number, port->slave->dev->name);
1470 		}
1471 	}
1472 	/* if all aggregator's ports are READY_N == TRUE, set ready=TRUE
1473 	 * in all aggregator's ports, else set ready=FALSE in all
1474 	 * aggregator's ports
1475 	 */
1476 	__set_agg_ports_ready(port->aggregator,
1477 			      __agg_ports_are_ready(port->aggregator));
1478 
1479 	aggregator = __get_first_agg(port);
1480 	ad_agg_selection_logic(aggregator, update_slave_arr);
1481 
1482 	if (!port->aggregator->is_active)
1483 		port->actor_oper_port_state &= ~AD_STATE_SYNCHRONIZATION;
1484 }
1485 
1486 /* Decide if "agg" is a better choice for the new active aggregator that
1487  * the current best, according to the ad_select policy.
1488  */
1489 static struct aggregator *ad_agg_selection_test(struct aggregator *best,
1490 						struct aggregator *curr)
1491 {
1492 	/* 0. If no best, select current.
1493 	 *
1494 	 * 1. If the current agg is not individual, and the best is
1495 	 *    individual, select current.
1496 	 *
1497 	 * 2. If current agg is individual and the best is not, keep best.
1498 	 *
1499 	 * 3. Therefore, current and best are both individual or both not
1500 	 *    individual, so:
1501 	 *
1502 	 * 3a. If current agg partner replied, and best agg partner did not,
1503 	 *     select current.
1504 	 *
1505 	 * 3b. If current agg partner did not reply and best agg partner
1506 	 *     did reply, keep best.
1507 	 *
1508 	 * 4.  Therefore, current and best both have partner replies or
1509 	 *     both do not, so perform selection policy:
1510 	 *
1511 	 * BOND_AD_COUNT: Select by count of ports.  If count is equal,
1512 	 *     select by bandwidth.
1513 	 *
1514 	 * BOND_AD_STABLE, BOND_AD_BANDWIDTH: Select by bandwidth.
1515 	 */
1516 	if (!best)
1517 		return curr;
1518 
1519 	if (!curr->is_individual && best->is_individual)
1520 		return curr;
1521 
1522 	if (curr->is_individual && !best->is_individual)
1523 		return best;
1524 
1525 	if (__agg_has_partner(curr) && !__agg_has_partner(best))
1526 		return curr;
1527 
1528 	if (!__agg_has_partner(curr) && __agg_has_partner(best))
1529 		return best;
1530 
1531 	switch (__get_agg_selection_mode(curr->lag_ports)) {
1532 	case BOND_AD_COUNT:
1533 		if (curr->num_of_ports > best->num_of_ports)
1534 			return curr;
1535 
1536 		if (curr->num_of_ports < best->num_of_ports)
1537 			return best;
1538 
1539 		/*FALLTHROUGH*/
1540 	case BOND_AD_STABLE:
1541 	case BOND_AD_BANDWIDTH:
1542 		if (__get_agg_bandwidth(curr) > __get_agg_bandwidth(best))
1543 			return curr;
1544 
1545 		break;
1546 
1547 	default:
1548 		net_warn_ratelimited("%s: Impossible agg select mode %d\n",
1549 				     curr->slave->bond->dev->name,
1550 				     __get_agg_selection_mode(curr->lag_ports));
1551 		break;
1552 	}
1553 
1554 	return best;
1555 }
1556 
1557 static int agg_device_up(const struct aggregator *agg)
1558 {
1559 	struct port *port = agg->lag_ports;
1560 
1561 	if (!port)
1562 		return 0;
1563 
1564 	return netif_running(port->slave->dev) &&
1565 	       netif_carrier_ok(port->slave->dev);
1566 }
1567 
1568 /**
1569  * ad_agg_selection_logic - select an aggregation group for a team
1570  * @aggregator: the aggregator we're looking at
1571  * @update_slave_arr: Does slave array need update?
1572  *
1573  * It is assumed that only one aggregator may be selected for a team.
1574  *
1575  * The logic of this function is to select the aggregator according to
1576  * the ad_select policy:
1577  *
1578  * BOND_AD_STABLE: select the aggregator with the most ports attached to
1579  * it, and to reselect the active aggregator only if the previous
1580  * aggregator has no more ports related to it.
1581  *
1582  * BOND_AD_BANDWIDTH: select the aggregator with the highest total
1583  * bandwidth, and reselect whenever a link state change takes place or the
1584  * set of slaves in the bond changes.
1585  *
1586  * BOND_AD_COUNT: select the aggregator with largest number of ports
1587  * (slaves), and reselect whenever a link state change takes place or the
1588  * set of slaves in the bond changes.
1589  *
1590  * FIXME: this function MUST be called with the first agg in the bond, or
1591  * __get_active_agg() won't work correctly. This function should be better
1592  * called with the bond itself, and retrieve the first agg from it.
1593  */
1594 static void ad_agg_selection_logic(struct aggregator *agg,
1595 				   bool *update_slave_arr)
1596 {
1597 	struct aggregator *best, *active, *origin;
1598 	struct bonding *bond = agg->slave->bond;
1599 	struct list_head *iter;
1600 	struct slave *slave;
1601 	struct port *port;
1602 
1603 	rcu_read_lock();
1604 	origin = agg;
1605 	active = __get_active_agg(agg);
1606 	best = (active && agg_device_up(active)) ? active : NULL;
1607 
1608 	bond_for_each_slave_rcu(bond, slave, iter) {
1609 		agg = &(SLAVE_AD_INFO(slave)->aggregator);
1610 
1611 		agg->is_active = 0;
1612 
1613 		if (agg->num_of_ports && agg_device_up(agg))
1614 			best = ad_agg_selection_test(best, agg);
1615 	}
1616 
1617 	if (best &&
1618 	    __get_agg_selection_mode(best->lag_ports) == BOND_AD_STABLE) {
1619 		/* For the STABLE policy, don't replace the old active
1620 		 * aggregator if it's still active (it has an answering
1621 		 * partner) or if both the best and active don't have an
1622 		 * answering partner.
1623 		 */
1624 		if (active && active->lag_ports &&
1625 		    active->lag_ports->is_enabled &&
1626 		    (__agg_has_partner(active) ||
1627 		     (!__agg_has_partner(active) &&
1628 		     !__agg_has_partner(best)))) {
1629 			if (!(!active->actor_oper_aggregator_key &&
1630 			      best->actor_oper_aggregator_key)) {
1631 				best = NULL;
1632 				active->is_active = 1;
1633 			}
1634 		}
1635 	}
1636 
1637 	if (best && (best == active)) {
1638 		best = NULL;
1639 		active->is_active = 1;
1640 	}
1641 
1642 	/* if there is new best aggregator, activate it */
1643 	if (best) {
1644 		netdev_dbg(bond->dev, "best Agg=%d; P=%d; a k=%d; p k=%d; Ind=%d; Act=%d\n",
1645 			   best->aggregator_identifier, best->num_of_ports,
1646 			   best->actor_oper_aggregator_key,
1647 			   best->partner_oper_aggregator_key,
1648 			   best->is_individual, best->is_active);
1649 		netdev_dbg(bond->dev, "best ports %p slave %p %s\n",
1650 			   best->lag_ports, best->slave,
1651 			   best->slave ? best->slave->dev->name : "NULL");
1652 
1653 		bond_for_each_slave_rcu(bond, slave, iter) {
1654 			agg = &(SLAVE_AD_INFO(slave)->aggregator);
1655 
1656 			netdev_dbg(bond->dev, "Agg=%d; P=%d; a k=%d; p k=%d; Ind=%d; Act=%d\n",
1657 				   agg->aggregator_identifier, agg->num_of_ports,
1658 				   agg->actor_oper_aggregator_key,
1659 				   agg->partner_oper_aggregator_key,
1660 				   agg->is_individual, agg->is_active);
1661 		}
1662 
1663 		/* check if any partner replys */
1664 		if (best->is_individual) {
1665 			net_warn_ratelimited("%s: Warning: No 802.3ad response from the link partner for any adapters in the bond\n",
1666 					     best->slave ?
1667 					     best->slave->bond->dev->name : "NULL");
1668 		}
1669 
1670 		best->is_active = 1;
1671 		netdev_dbg(bond->dev, "LAG %d chosen as the active LAG\n",
1672 			   best->aggregator_identifier);
1673 		netdev_dbg(bond->dev, "Agg=%d; P=%d; a k=%d; p k=%d; Ind=%d; Act=%d\n",
1674 			   best->aggregator_identifier, best->num_of_ports,
1675 			   best->actor_oper_aggregator_key,
1676 			   best->partner_oper_aggregator_key,
1677 			   best->is_individual, best->is_active);
1678 
1679 		/* disable the ports that were related to the former
1680 		 * active_aggregator
1681 		 */
1682 		if (active) {
1683 			for (port = active->lag_ports; port;
1684 			     port = port->next_port_in_aggregator) {
1685 				__disable_port(port);
1686 			}
1687 		}
1688 		/* Slave array needs update. */
1689 		*update_slave_arr = true;
1690 	}
1691 
1692 	/* if the selected aggregator is of join individuals
1693 	 * (partner_system is NULL), enable their ports
1694 	 */
1695 	active = __get_active_agg(origin);
1696 
1697 	if (active) {
1698 		if (!__agg_has_partner(active)) {
1699 			for (port = active->lag_ports; port;
1700 			     port = port->next_port_in_aggregator) {
1701 				__enable_port(port);
1702 			}
1703 		}
1704 	}
1705 
1706 	rcu_read_unlock();
1707 
1708 	bond_3ad_set_carrier(bond);
1709 }
1710 
1711 /**
1712  * ad_clear_agg - clear a given aggregator's parameters
1713  * @aggregator: the aggregator we're looking at
1714  */
1715 static void ad_clear_agg(struct aggregator *aggregator)
1716 {
1717 	if (aggregator) {
1718 		aggregator->is_individual = false;
1719 		aggregator->actor_admin_aggregator_key = 0;
1720 		aggregator->actor_oper_aggregator_key = 0;
1721 		aggregator->partner_system = null_mac_addr;
1722 		aggregator->partner_system_priority = 0;
1723 		aggregator->partner_oper_aggregator_key = 0;
1724 		aggregator->receive_state = 0;
1725 		aggregator->transmit_state = 0;
1726 		aggregator->lag_ports = NULL;
1727 		aggregator->is_active = 0;
1728 		aggregator->num_of_ports = 0;
1729 		pr_debug("LAG %d was cleared\n",
1730 			 aggregator->aggregator_identifier);
1731 	}
1732 }
1733 
1734 /**
1735  * ad_initialize_agg - initialize a given aggregator's parameters
1736  * @aggregator: the aggregator we're looking at
1737  */
1738 static void ad_initialize_agg(struct aggregator *aggregator)
1739 {
1740 	if (aggregator) {
1741 		ad_clear_agg(aggregator);
1742 
1743 		aggregator->aggregator_mac_address = null_mac_addr;
1744 		aggregator->aggregator_identifier = 0;
1745 		aggregator->slave = NULL;
1746 	}
1747 }
1748 
1749 /**
1750  * ad_initialize_port - initialize a given port's parameters
1751  * @aggregator: the aggregator we're looking at
1752  * @lacp_fast: boolean. whether fast periodic should be used
1753  */
1754 static void ad_initialize_port(struct port *port, int lacp_fast)
1755 {
1756 	static const struct port_params tmpl = {
1757 		.system_priority = 0xffff,
1758 		.key             = 1,
1759 		.port_number     = 1,
1760 		.port_priority   = 0xff,
1761 		.port_state      = 1,
1762 	};
1763 	static const struct lacpdu lacpdu = {
1764 		.subtype		= 0x01,
1765 		.version_number = 0x01,
1766 		.tlv_type_actor_info = 0x01,
1767 		.actor_information_length = 0x14,
1768 		.tlv_type_partner_info = 0x02,
1769 		.partner_information_length = 0x14,
1770 		.tlv_type_collector_info = 0x03,
1771 		.collector_information_length = 0x10,
1772 		.collector_max_delay = htons(AD_COLLECTOR_MAX_DELAY),
1773 	};
1774 
1775 	if (port) {
1776 		port->actor_port_priority = 0xff;
1777 		port->actor_port_aggregator_identifier = 0;
1778 		port->ntt = false;
1779 		port->actor_admin_port_state = AD_STATE_AGGREGATION |
1780 					       AD_STATE_LACP_ACTIVITY;
1781 		port->actor_oper_port_state  = AD_STATE_AGGREGATION |
1782 					       AD_STATE_LACP_ACTIVITY;
1783 
1784 		if (lacp_fast)
1785 			port->actor_oper_port_state |= AD_STATE_LACP_TIMEOUT;
1786 
1787 		memcpy(&port->partner_admin, &tmpl, sizeof(tmpl));
1788 		memcpy(&port->partner_oper, &tmpl, sizeof(tmpl));
1789 
1790 		port->is_enabled = true;
1791 		/* private parameters */
1792 		port->sm_vars = AD_PORT_BEGIN | AD_PORT_LACP_ENABLED;
1793 		port->sm_rx_state = 0;
1794 		port->sm_rx_timer_counter = 0;
1795 		port->sm_periodic_state = 0;
1796 		port->sm_periodic_timer_counter = 0;
1797 		port->sm_mux_state = 0;
1798 		port->sm_mux_timer_counter = 0;
1799 		port->sm_tx_state = 0;
1800 		port->aggregator = NULL;
1801 		port->next_port_in_aggregator = NULL;
1802 		port->transaction_id = 0;
1803 
1804 		port->sm_churn_actor_timer_counter = 0;
1805 		port->sm_churn_actor_state = 0;
1806 		port->churn_actor_count = 0;
1807 		port->sm_churn_partner_timer_counter = 0;
1808 		port->sm_churn_partner_state = 0;
1809 		port->churn_partner_count = 0;
1810 
1811 		memcpy(&port->lacpdu, &lacpdu, sizeof(lacpdu));
1812 	}
1813 }
1814 
1815 /**
1816  * ad_enable_collecting_distributing - enable a port's transmit/receive
1817  * @port: the port we're looking at
1818  * @update_slave_arr: Does slave array need update?
1819  *
1820  * Enable @port if it's in an active aggregator
1821  */
1822 static void ad_enable_collecting_distributing(struct port *port,
1823 					      bool *update_slave_arr)
1824 {
1825 	if (port->aggregator->is_active) {
1826 		pr_debug("Enabling port %d(LAG %d)\n",
1827 			 port->actor_port_number,
1828 			 port->aggregator->aggregator_identifier);
1829 		__enable_port(port);
1830 		/* Slave array needs update */
1831 		*update_slave_arr = true;
1832 	}
1833 }
1834 
1835 /**
1836  * ad_disable_collecting_distributing - disable a port's transmit/receive
1837  * @port: the port we're looking at
1838  * @update_slave_arr: Does slave array need update?
1839  */
1840 static void ad_disable_collecting_distributing(struct port *port,
1841 					       bool *update_slave_arr)
1842 {
1843 	if (port->aggregator &&
1844 	    !MAC_ADDRESS_EQUAL(&(port->aggregator->partner_system),
1845 			       &(null_mac_addr))) {
1846 		pr_debug("Disabling port %d(LAG %d)\n",
1847 			 port->actor_port_number,
1848 			 port->aggregator->aggregator_identifier);
1849 		__disable_port(port);
1850 		/* Slave array needs an update */
1851 		*update_slave_arr = true;
1852 	}
1853 }
1854 
1855 /**
1856  * ad_marker_info_received - handle receive of a Marker information frame
1857  * @marker_info: Marker info received
1858  * @port: the port we're looking at
1859  */
1860 static void ad_marker_info_received(struct bond_marker *marker_info,
1861 	struct port *port)
1862 {
1863 	struct bond_marker marker;
1864 
1865 	/* copy the received marker data to the response marker */
1866 	memcpy(&marker, marker_info, sizeof(struct bond_marker));
1867 	/* change the marker subtype to marker response */
1868 	marker.tlv_type = AD_MARKER_RESPONSE_SUBTYPE;
1869 
1870 	/* send the marker response */
1871 	if (ad_marker_send(port, &marker) >= 0) {
1872 		pr_debug("Sent Marker Response on port %d\n",
1873 			 port->actor_port_number);
1874 	}
1875 }
1876 
1877 /**
1878  * ad_marker_response_received - handle receive of a marker response frame
1879  * @marker: marker PDU received
1880  * @port: the port we're looking at
1881  *
1882  * This function does nothing since we decided not to implement send and handle
1883  * response for marker PDU's, in this stage, but only to respond to marker
1884  * information.
1885  */
1886 static void ad_marker_response_received(struct bond_marker *marker,
1887 					struct port *port)
1888 {
1889 	/* DO NOTHING, SINCE WE DECIDED NOT TO IMPLEMENT THIS FEATURE FOR NOW */
1890 }
1891 
1892 /* ========= AD exported functions to the main bonding code ========= */
1893 
1894 /* Check aggregators status in team every T seconds */
1895 #define AD_AGGREGATOR_SELECTION_TIMER  8
1896 
1897 /**
1898  * bond_3ad_initiate_agg_selection - initate aggregator selection
1899  * @bond: bonding struct
1900  *
1901  * Set the aggregation selection timer, to initiate an agg selection in
1902  * the very near future.  Called during first initialization, and during
1903  * any down to up transitions of the bond.
1904  */
1905 void bond_3ad_initiate_agg_selection(struct bonding *bond, int timeout)
1906 {
1907 	BOND_AD_INFO(bond).agg_select_timer = timeout;
1908 }
1909 
1910 /**
1911  * bond_3ad_initialize - initialize a bond's 802.3ad parameters and structures
1912  * @bond: bonding struct to work on
1913  * @tick_resolution: tick duration (millisecond resolution)
1914  *
1915  * Can be called only after the mac address of the bond is set.
1916  */
1917 void bond_3ad_initialize(struct bonding *bond, u16 tick_resolution)
1918 {
1919 	/* check that the bond is not initialized yet */
1920 	if (!MAC_ADDRESS_EQUAL(&(BOND_AD_INFO(bond).system.sys_mac_addr),
1921 				bond->dev->dev_addr)) {
1922 
1923 		BOND_AD_INFO(bond).aggregator_identifier = 0;
1924 
1925 		BOND_AD_INFO(bond).system.sys_priority =
1926 			bond->params.ad_actor_sys_prio;
1927 		if (is_zero_ether_addr(bond->params.ad_actor_system))
1928 			BOND_AD_INFO(bond).system.sys_mac_addr =
1929 			    *((struct mac_addr *)bond->dev->dev_addr);
1930 		else
1931 			BOND_AD_INFO(bond).system.sys_mac_addr =
1932 			    *((struct mac_addr *)bond->params.ad_actor_system);
1933 
1934 		/* initialize how many times this module is called in one
1935 		 * second (should be about every 100ms)
1936 		 */
1937 		ad_ticks_per_sec = tick_resolution;
1938 
1939 		bond_3ad_initiate_agg_selection(bond,
1940 						AD_AGGREGATOR_SELECTION_TIMER *
1941 						ad_ticks_per_sec);
1942 	}
1943 }
1944 
1945 /**
1946  * bond_3ad_bind_slave - initialize a slave's port
1947  * @slave: slave struct to work on
1948  *
1949  * Returns:   0 on success
1950  *          < 0 on error
1951  */
1952 void bond_3ad_bind_slave(struct slave *slave)
1953 {
1954 	struct bonding *bond = bond_get_bond_by_slave(slave);
1955 	struct port *port;
1956 	struct aggregator *aggregator;
1957 
1958 	/* check that the slave has not been initialized yet. */
1959 	if (SLAVE_AD_INFO(slave)->port.slave != slave) {
1960 
1961 		/* port initialization */
1962 		port = &(SLAVE_AD_INFO(slave)->port);
1963 
1964 		ad_initialize_port(port, bond->params.lacp_fast);
1965 
1966 		port->slave = slave;
1967 		port->actor_port_number = SLAVE_AD_INFO(slave)->id;
1968 		/* key is determined according to the link speed, duplex and
1969 		 * user key
1970 		 */
1971 		port->actor_admin_port_key = bond->params.ad_user_port_key << 6;
1972 		ad_update_actor_keys(port, false);
1973 		/* actor system is the bond's system */
1974 		__ad_actor_update_port(port);
1975 		/* tx timer(to verify that no more than MAX_TX_IN_SECOND
1976 		 * lacpdu's are sent in one second)
1977 		 */
1978 		port->sm_tx_timer_counter = ad_ticks_per_sec/AD_MAX_TX_IN_SECOND;
1979 
1980 		__disable_port(port);
1981 
1982 		/* aggregator initialization */
1983 		aggregator = &(SLAVE_AD_INFO(slave)->aggregator);
1984 
1985 		ad_initialize_agg(aggregator);
1986 
1987 		aggregator->aggregator_mac_address = *((struct mac_addr *)bond->dev->dev_addr);
1988 		aggregator->aggregator_identifier = ++BOND_AD_INFO(bond).aggregator_identifier;
1989 		aggregator->slave = slave;
1990 		aggregator->is_active = 0;
1991 		aggregator->num_of_ports = 0;
1992 	}
1993 }
1994 
1995 /**
1996  * bond_3ad_unbind_slave - deinitialize a slave's port
1997  * @slave: slave struct to work on
1998  *
1999  * Search for the aggregator that is related to this port, remove the
2000  * aggregator and assign another aggregator for other port related to it
2001  * (if any), and remove the port.
2002  */
2003 void bond_3ad_unbind_slave(struct slave *slave)
2004 {
2005 	struct port *port, *prev_port, *temp_port;
2006 	struct aggregator *aggregator, *new_aggregator, *temp_aggregator;
2007 	int select_new_active_agg = 0;
2008 	struct bonding *bond = slave->bond;
2009 	struct slave *slave_iter;
2010 	struct list_head *iter;
2011 	bool dummy_slave_update; /* Ignore this value as caller updates array */
2012 
2013 	/* Sync against bond_3ad_state_machine_handler() */
2014 	spin_lock_bh(&bond->mode_lock);
2015 	aggregator = &(SLAVE_AD_INFO(slave)->aggregator);
2016 	port = &(SLAVE_AD_INFO(slave)->port);
2017 
2018 	/* if slave is null, the whole port is not initialized */
2019 	if (!port->slave) {
2020 		netdev_warn(bond->dev, "Trying to unbind an uninitialized port on %s\n",
2021 			    slave->dev->name);
2022 		goto out;
2023 	}
2024 
2025 	netdev_dbg(bond->dev, "Unbinding Link Aggregation Group %d\n",
2026 		   aggregator->aggregator_identifier);
2027 
2028 	/* Tell the partner that this port is not suitable for aggregation */
2029 	port->actor_oper_port_state &= ~AD_STATE_AGGREGATION;
2030 	__update_lacpdu_from_port(port);
2031 	ad_lacpdu_send(port);
2032 
2033 	/* check if this aggregator is occupied */
2034 	if (aggregator->lag_ports) {
2035 		/* check if there are other ports related to this aggregator
2036 		 * except the port related to this slave(thats ensure us that
2037 		 * there is a reason to search for new aggregator, and that we
2038 		 * will find one
2039 		 */
2040 		if ((aggregator->lag_ports != port) ||
2041 		    (aggregator->lag_ports->next_port_in_aggregator)) {
2042 			/* find new aggregator for the related port(s) */
2043 			bond_for_each_slave(bond, slave_iter, iter) {
2044 				new_aggregator = &(SLAVE_AD_INFO(slave_iter)->aggregator);
2045 				/* if the new aggregator is empty, or it is
2046 				 * connected to our port only
2047 				 */
2048 				if (!new_aggregator->lag_ports ||
2049 				    ((new_aggregator->lag_ports == port) &&
2050 				     !new_aggregator->lag_ports->next_port_in_aggregator))
2051 					break;
2052 			}
2053 			if (!slave_iter)
2054 				new_aggregator = NULL;
2055 
2056 			/* if new aggregator found, copy the aggregator's
2057 			 * parameters and connect the related lag_ports to the
2058 			 * new aggregator
2059 			 */
2060 			if ((new_aggregator) && ((!new_aggregator->lag_ports) || ((new_aggregator->lag_ports == port) && !new_aggregator->lag_ports->next_port_in_aggregator))) {
2061 				netdev_dbg(bond->dev, "Some port(s) related to LAG %d - replacing with LAG %d\n",
2062 					   aggregator->aggregator_identifier,
2063 					   new_aggregator->aggregator_identifier);
2064 
2065 				if ((new_aggregator->lag_ports == port) &&
2066 				    new_aggregator->is_active) {
2067 					netdev_info(bond->dev, "Removing an active aggregator\n");
2068 					 select_new_active_agg = 1;
2069 				}
2070 
2071 				new_aggregator->is_individual = aggregator->is_individual;
2072 				new_aggregator->actor_admin_aggregator_key = aggregator->actor_admin_aggregator_key;
2073 				new_aggregator->actor_oper_aggregator_key = aggregator->actor_oper_aggregator_key;
2074 				new_aggregator->partner_system = aggregator->partner_system;
2075 				new_aggregator->partner_system_priority = aggregator->partner_system_priority;
2076 				new_aggregator->partner_oper_aggregator_key = aggregator->partner_oper_aggregator_key;
2077 				new_aggregator->receive_state = aggregator->receive_state;
2078 				new_aggregator->transmit_state = aggregator->transmit_state;
2079 				new_aggregator->lag_ports = aggregator->lag_ports;
2080 				new_aggregator->is_active = aggregator->is_active;
2081 				new_aggregator->num_of_ports = aggregator->num_of_ports;
2082 
2083 				/* update the information that is written on
2084 				 * the ports about the aggregator
2085 				 */
2086 				for (temp_port = aggregator->lag_ports; temp_port;
2087 				     temp_port = temp_port->next_port_in_aggregator) {
2088 					temp_port->aggregator = new_aggregator;
2089 					temp_port->actor_port_aggregator_identifier = new_aggregator->aggregator_identifier;
2090 				}
2091 
2092 				ad_clear_agg(aggregator);
2093 
2094 				if (select_new_active_agg)
2095 					ad_agg_selection_logic(__get_first_agg(port),
2096 							       &dummy_slave_update);
2097 			} else {
2098 				netdev_warn(bond->dev, "unbinding aggregator, and could not find a new aggregator for its ports\n");
2099 			}
2100 		} else {
2101 			/* in case that the only port related to this
2102 			 * aggregator is the one we want to remove
2103 			 */
2104 			select_new_active_agg = aggregator->is_active;
2105 			ad_clear_agg(aggregator);
2106 			if (select_new_active_agg) {
2107 				netdev_info(bond->dev, "Removing an active aggregator\n");
2108 				/* select new active aggregator */
2109 				temp_aggregator = __get_first_agg(port);
2110 				if (temp_aggregator)
2111 					ad_agg_selection_logic(temp_aggregator,
2112 							       &dummy_slave_update);
2113 			}
2114 		}
2115 	}
2116 
2117 	netdev_dbg(bond->dev, "Unbinding port %d\n", port->actor_port_number);
2118 
2119 	/* find the aggregator that this port is connected to */
2120 	bond_for_each_slave(bond, slave_iter, iter) {
2121 		temp_aggregator = &(SLAVE_AD_INFO(slave_iter)->aggregator);
2122 		prev_port = NULL;
2123 		/* search the port in the aggregator's related ports */
2124 		for (temp_port = temp_aggregator->lag_ports; temp_port;
2125 		     prev_port = temp_port,
2126 		     temp_port = temp_port->next_port_in_aggregator) {
2127 			if (temp_port == port) {
2128 				/* the aggregator found - detach the port from
2129 				 * this aggregator
2130 				 */
2131 				if (prev_port)
2132 					prev_port->next_port_in_aggregator = temp_port->next_port_in_aggregator;
2133 				else
2134 					temp_aggregator->lag_ports = temp_port->next_port_in_aggregator;
2135 				temp_aggregator->num_of_ports--;
2136 				if (temp_aggregator->num_of_ports == 0) {
2137 					select_new_active_agg = temp_aggregator->is_active;
2138 					ad_clear_agg(temp_aggregator);
2139 					if (select_new_active_agg) {
2140 						netdev_info(bond->dev, "Removing an active aggregator\n");
2141 						/* select new active aggregator */
2142 						ad_agg_selection_logic(__get_first_agg(port),
2143 							               &dummy_slave_update);
2144 					}
2145 				}
2146 				break;
2147 			}
2148 		}
2149 	}
2150 	port->slave = NULL;
2151 
2152 out:
2153 	spin_unlock_bh(&bond->mode_lock);
2154 }
2155 
2156 /**
2157  * bond_3ad_update_ad_actor_settings - reflect change of actor settings to ports
2158  * @bond: bonding struct to work on
2159  *
2160  * If an ad_actor setting gets changed we need to update the individual port
2161  * settings so the bond device will use the new values when it gets upped.
2162  */
2163 void bond_3ad_update_ad_actor_settings(struct bonding *bond)
2164 {
2165 	struct list_head *iter;
2166 	struct slave *slave;
2167 
2168 	ASSERT_RTNL();
2169 
2170 	BOND_AD_INFO(bond).system.sys_priority = bond->params.ad_actor_sys_prio;
2171 	if (is_zero_ether_addr(bond->params.ad_actor_system))
2172 		BOND_AD_INFO(bond).system.sys_mac_addr =
2173 		    *((struct mac_addr *)bond->dev->dev_addr);
2174 	else
2175 		BOND_AD_INFO(bond).system.sys_mac_addr =
2176 		    *((struct mac_addr *)bond->params.ad_actor_system);
2177 
2178 	spin_lock_bh(&bond->mode_lock);
2179 	bond_for_each_slave(bond, slave, iter) {
2180 		struct port *port = &(SLAVE_AD_INFO(slave))->port;
2181 
2182 		__ad_actor_update_port(port);
2183 		port->ntt = true;
2184 	}
2185 	spin_unlock_bh(&bond->mode_lock);
2186 }
2187 
2188 /**
2189  * bond_3ad_state_machine_handler - handle state machines timeout
2190  * @bond: bonding struct to work on
2191  *
2192  * The state machine handling concept in this module is to check every tick
2193  * which state machine should operate any function. The execution order is
2194  * round robin, so when we have an interaction between state machines, the
2195  * reply of one to each other might be delayed until next tick.
2196  *
2197  * This function also complete the initialization when the agg_select_timer
2198  * times out, and it selects an aggregator for the ports that are yet not
2199  * related to any aggregator, and selects the active aggregator for a bond.
2200  */
2201 void bond_3ad_state_machine_handler(struct work_struct *work)
2202 {
2203 	struct bonding *bond = container_of(work, struct bonding,
2204 					    ad_work.work);
2205 	struct aggregator *aggregator;
2206 	struct list_head *iter;
2207 	struct slave *slave;
2208 	struct port *port;
2209 	bool should_notify_rtnl = BOND_SLAVE_NOTIFY_LATER;
2210 	bool update_slave_arr = false;
2211 
2212 	/* Lock to protect data accessed by all (e.g., port->sm_vars) and
2213 	 * against running with bond_3ad_unbind_slave. ad_rx_machine may run
2214 	 * concurrently due to incoming LACPDU as well.
2215 	 */
2216 	spin_lock_bh(&bond->mode_lock);
2217 	rcu_read_lock();
2218 
2219 	/* check if there are any slaves */
2220 	if (!bond_has_slaves(bond))
2221 		goto re_arm;
2222 
2223 	/* check if agg_select_timer timer after initialize is timed out */
2224 	if (BOND_AD_INFO(bond).agg_select_timer &&
2225 	    !(--BOND_AD_INFO(bond).agg_select_timer)) {
2226 		slave = bond_first_slave_rcu(bond);
2227 		port = slave ? &(SLAVE_AD_INFO(slave)->port) : NULL;
2228 
2229 		/* select the active aggregator for the bond */
2230 		if (port) {
2231 			if (!port->slave) {
2232 				net_warn_ratelimited("%s: Warning: bond's first port is uninitialized\n",
2233 						     bond->dev->name);
2234 				goto re_arm;
2235 			}
2236 
2237 			aggregator = __get_first_agg(port);
2238 			ad_agg_selection_logic(aggregator, &update_slave_arr);
2239 		}
2240 		bond_3ad_set_carrier(bond);
2241 	}
2242 
2243 	/* for each port run the state machines */
2244 	bond_for_each_slave_rcu(bond, slave, iter) {
2245 		port = &(SLAVE_AD_INFO(slave)->port);
2246 		if (!port->slave) {
2247 			net_warn_ratelimited("%s: Warning: Found an uninitialized port\n",
2248 					    bond->dev->name);
2249 			goto re_arm;
2250 		}
2251 
2252 		ad_rx_machine(NULL, port);
2253 		ad_periodic_machine(port);
2254 		ad_port_selection_logic(port, &update_slave_arr);
2255 		ad_mux_machine(port, &update_slave_arr);
2256 		ad_tx_machine(port);
2257 		ad_churn_machine(port);
2258 
2259 		/* turn off the BEGIN bit, since we already handled it */
2260 		if (port->sm_vars & AD_PORT_BEGIN)
2261 			port->sm_vars &= ~AD_PORT_BEGIN;
2262 	}
2263 
2264 re_arm:
2265 	bond_for_each_slave_rcu(bond, slave, iter) {
2266 		if (slave->should_notify) {
2267 			should_notify_rtnl = BOND_SLAVE_NOTIFY_NOW;
2268 			break;
2269 		}
2270 	}
2271 	rcu_read_unlock();
2272 	spin_unlock_bh(&bond->mode_lock);
2273 
2274 	if (update_slave_arr)
2275 		bond_slave_arr_work_rearm(bond, 0);
2276 
2277 	if (should_notify_rtnl && rtnl_trylock()) {
2278 		bond_slave_state_notify(bond);
2279 		rtnl_unlock();
2280 	}
2281 	queue_delayed_work(bond->wq, &bond->ad_work, ad_delta_in_ticks);
2282 }
2283 
2284 /**
2285  * bond_3ad_rx_indication - handle a received frame
2286  * @lacpdu: received lacpdu
2287  * @slave: slave struct to work on
2288  * @length: length of the data received
2289  *
2290  * It is assumed that frames that were sent on this NIC don't returned as new
2291  * received frames (loopback). Since only the payload is given to this
2292  * function, it check for loopback.
2293  */
2294 static int bond_3ad_rx_indication(struct lacpdu *lacpdu, struct slave *slave,
2295 				  u16 length)
2296 {
2297 	struct port *port;
2298 	int ret = RX_HANDLER_ANOTHER;
2299 
2300 	if (length >= sizeof(struct lacpdu)) {
2301 
2302 		port = &(SLAVE_AD_INFO(slave)->port);
2303 
2304 		if (!port->slave) {
2305 			net_warn_ratelimited("%s: Warning: port of slave %s is uninitialized\n",
2306 					     slave->dev->name, slave->bond->dev->name);
2307 			return ret;
2308 		}
2309 
2310 		switch (lacpdu->subtype) {
2311 		case AD_TYPE_LACPDU:
2312 			ret = RX_HANDLER_CONSUMED;
2313 			netdev_dbg(slave->bond->dev,
2314 				   "Received LACPDU on port %d slave %s\n",
2315 				   port->actor_port_number,
2316 				   slave->dev->name);
2317 			/* Protect against concurrent state machines */
2318 			spin_lock(&slave->bond->mode_lock);
2319 			ad_rx_machine(lacpdu, port);
2320 			spin_unlock(&slave->bond->mode_lock);
2321 			break;
2322 
2323 		case AD_TYPE_MARKER:
2324 			ret = RX_HANDLER_CONSUMED;
2325 			/* No need to convert fields to Little Endian since we
2326 			 * don't use the marker's fields.
2327 			 */
2328 
2329 			switch (((struct bond_marker *)lacpdu)->tlv_type) {
2330 			case AD_MARKER_INFORMATION_SUBTYPE:
2331 				netdev_dbg(slave->bond->dev, "Received Marker Information on port %d\n",
2332 					   port->actor_port_number);
2333 				ad_marker_info_received((struct bond_marker *)lacpdu, port);
2334 				break;
2335 
2336 			case AD_MARKER_RESPONSE_SUBTYPE:
2337 				netdev_dbg(slave->bond->dev, "Received Marker Response on port %d\n",
2338 					   port->actor_port_number);
2339 				ad_marker_response_received((struct bond_marker *)lacpdu, port);
2340 				break;
2341 
2342 			default:
2343 				netdev_dbg(slave->bond->dev, "Received an unknown Marker subtype on slot %d\n",
2344 					   port->actor_port_number);
2345 			}
2346 		}
2347 	}
2348 	return ret;
2349 }
2350 
2351 /**
2352  * ad_update_actor_keys - Update the oper / admin keys for a port based on
2353  * its current speed and duplex settings.
2354  *
2355  * @port: the port we'are looking at
2356  * @reset: Boolean to just reset the speed and the duplex part of the key
2357  *
2358  * The logic to change the oper / admin keys is:
2359  * (a) A full duplex port can participate in LACP with partner.
2360  * (b) When the speed is changed, LACP need to be reinitiated.
2361  */
2362 static void ad_update_actor_keys(struct port *port, bool reset)
2363 {
2364 	u8 duplex = 0;
2365 	u16 ospeed = 0, speed = 0;
2366 	u16 old_oper_key = port->actor_oper_port_key;
2367 
2368 	port->actor_admin_port_key &= ~(AD_SPEED_KEY_MASKS|AD_DUPLEX_KEY_MASKS);
2369 	if (!reset) {
2370 		speed = __get_link_speed(port);
2371 		ospeed = (old_oper_key & AD_SPEED_KEY_MASKS) >> 1;
2372 		duplex = __get_duplex(port);
2373 		port->actor_admin_port_key |= (speed << 1) | duplex;
2374 	}
2375 	port->actor_oper_port_key = port->actor_admin_port_key;
2376 
2377 	if (old_oper_key != port->actor_oper_port_key) {
2378 		/* Only 'duplex' port participates in LACP */
2379 		if (duplex)
2380 			port->sm_vars |= AD_PORT_LACP_ENABLED;
2381 		else
2382 			port->sm_vars &= ~AD_PORT_LACP_ENABLED;
2383 
2384 		if (!reset) {
2385 			if (!speed) {
2386 				netdev_err(port->slave->dev,
2387 					   "speed changed to 0 for port %s",
2388 					   port->slave->dev->name);
2389 			} else if (duplex && ospeed != speed) {
2390 				/* Speed change restarts LACP state-machine */
2391 				port->sm_vars |= AD_PORT_BEGIN;
2392 			}
2393 		}
2394 	}
2395 }
2396 
2397 /**
2398  * bond_3ad_adapter_speed_duplex_changed - handle a slave's speed / duplex
2399  * change indication
2400  *
2401  * @slave: slave struct to work on
2402  *
2403  * Handle reselection of aggregator (if needed) for this port.
2404  */
2405 void bond_3ad_adapter_speed_duplex_changed(struct slave *slave)
2406 {
2407 	struct port *port;
2408 
2409 	port = &(SLAVE_AD_INFO(slave)->port);
2410 
2411 	/* if slave is null, the whole port is not initialized */
2412 	if (!port->slave) {
2413 		netdev_warn(slave->bond->dev,
2414 			    "speed/duplex changed for uninitialized port %s\n",
2415 			    slave->dev->name);
2416 		return;
2417 	}
2418 
2419 	spin_lock_bh(&slave->bond->mode_lock);
2420 	ad_update_actor_keys(port, false);
2421 	netdev_dbg(slave->bond->dev, "Port %d slave %s changed speed/duplex\n",
2422 		   port->actor_port_number, slave->dev->name);
2423 	spin_unlock_bh(&slave->bond->mode_lock);
2424 }
2425 
2426 /**
2427  * bond_3ad_handle_link_change - handle a slave's link status change indication
2428  * @slave: slave struct to work on
2429  * @status: whether the link is now up or down
2430  *
2431  * Handle reselection of aggregator (if needed) for this port.
2432  */
2433 void bond_3ad_handle_link_change(struct slave *slave, char link)
2434 {
2435 	struct port *port;
2436 
2437 	port = &(SLAVE_AD_INFO(slave)->port);
2438 
2439 	/* if slave is null, the whole port is not initialized */
2440 	if (!port->slave) {
2441 		netdev_warn(slave->bond->dev, "link status changed for uninitialized port on %s\n",
2442 			    slave->dev->name);
2443 		return;
2444 	}
2445 
2446 	spin_lock_bh(&slave->bond->mode_lock);
2447 	/* on link down we are zeroing duplex and speed since
2448 	 * some of the adaptors(ce1000.lan) report full duplex/speed
2449 	 * instead of N/A(duplex) / 0(speed).
2450 	 *
2451 	 * on link up we are forcing recheck on the duplex and speed since
2452 	 * some of he adaptors(ce1000.lan) report.
2453 	 */
2454 	if (link == BOND_LINK_UP) {
2455 		port->is_enabled = true;
2456 		ad_update_actor_keys(port, false);
2457 	} else {
2458 		/* link has failed */
2459 		port->is_enabled = false;
2460 		ad_update_actor_keys(port, true);
2461 	}
2462 	netdev_dbg(slave->bond->dev, "Port %d changed link status to %s\n",
2463 		   port->actor_port_number,
2464 		   link == BOND_LINK_UP ? "UP" : "DOWN");
2465 
2466 	spin_unlock_bh(&slave->bond->mode_lock);
2467 
2468 	/* RTNL is held and mode_lock is released so it's safe
2469 	 * to update slave_array here.
2470 	 */
2471 	bond_update_slave_arr(slave->bond, NULL);
2472 }
2473 
2474 /**
2475  * bond_3ad_set_carrier - set link state for bonding master
2476  * @bond - bonding structure
2477  *
2478  * if we have an active aggregator, we're up, if not, we're down.
2479  * Presumes that we cannot have an active aggregator if there are
2480  * no slaves with link up.
2481  *
2482  * This behavior complies with IEEE 802.3 section 43.3.9.
2483  *
2484  * Called by bond_set_carrier(). Return zero if carrier state does not
2485  * change, nonzero if it does.
2486  */
2487 int bond_3ad_set_carrier(struct bonding *bond)
2488 {
2489 	struct aggregator *active;
2490 	struct slave *first_slave;
2491 	int ret = 1;
2492 
2493 	rcu_read_lock();
2494 	first_slave = bond_first_slave_rcu(bond);
2495 	if (!first_slave) {
2496 		ret = 0;
2497 		goto out;
2498 	}
2499 	active = __get_active_agg(&(SLAVE_AD_INFO(first_slave)->aggregator));
2500 	if (active) {
2501 		/* are enough slaves available to consider link up? */
2502 		if (active->num_of_ports < bond->params.min_links) {
2503 			if (netif_carrier_ok(bond->dev)) {
2504 				netif_carrier_off(bond->dev);
2505 				goto out;
2506 			}
2507 		} else if (!netif_carrier_ok(bond->dev)) {
2508 			netif_carrier_on(bond->dev);
2509 			goto out;
2510 		}
2511 	} else if (netif_carrier_ok(bond->dev)) {
2512 		netif_carrier_off(bond->dev);
2513 	}
2514 out:
2515 	rcu_read_unlock();
2516 	return ret;
2517 }
2518 
2519 /**
2520  * __bond_3ad_get_active_agg_info - get information of the active aggregator
2521  * @bond: bonding struct to work on
2522  * @ad_info: ad_info struct to fill with the bond's info
2523  *
2524  * Returns:   0 on success
2525  *          < 0 on error
2526  */
2527 int __bond_3ad_get_active_agg_info(struct bonding *bond,
2528 				   struct ad_info *ad_info)
2529 {
2530 	struct aggregator *aggregator = NULL;
2531 	struct list_head *iter;
2532 	struct slave *slave;
2533 	struct port *port;
2534 
2535 	bond_for_each_slave_rcu(bond, slave, iter) {
2536 		port = &(SLAVE_AD_INFO(slave)->port);
2537 		if (port->aggregator && port->aggregator->is_active) {
2538 			aggregator = port->aggregator;
2539 			break;
2540 		}
2541 	}
2542 
2543 	if (!aggregator)
2544 		return -1;
2545 
2546 	ad_info->aggregator_id = aggregator->aggregator_identifier;
2547 	ad_info->ports = aggregator->num_of_ports;
2548 	ad_info->actor_key = aggregator->actor_oper_aggregator_key;
2549 	ad_info->partner_key = aggregator->partner_oper_aggregator_key;
2550 	ether_addr_copy(ad_info->partner_system,
2551 			aggregator->partner_system.mac_addr_value);
2552 	return 0;
2553 }
2554 
2555 int bond_3ad_get_active_agg_info(struct bonding *bond, struct ad_info *ad_info)
2556 {
2557 	int ret;
2558 
2559 	rcu_read_lock();
2560 	ret = __bond_3ad_get_active_agg_info(bond, ad_info);
2561 	rcu_read_unlock();
2562 
2563 	return ret;
2564 }
2565 
2566 int bond_3ad_lacpdu_recv(const struct sk_buff *skb, struct bonding *bond,
2567 			 struct slave *slave)
2568 {
2569 	struct lacpdu *lacpdu, _lacpdu;
2570 
2571 	if (skb->protocol != PKT_TYPE_LACPDU)
2572 		return RX_HANDLER_ANOTHER;
2573 
2574 	if (!MAC_ADDRESS_EQUAL(eth_hdr(skb)->h_dest, lacpdu_mcast_addr))
2575 		return RX_HANDLER_ANOTHER;
2576 
2577 	lacpdu = skb_header_pointer(skb, 0, sizeof(_lacpdu), &_lacpdu);
2578 	if (!lacpdu)
2579 		return RX_HANDLER_ANOTHER;
2580 
2581 	return bond_3ad_rx_indication(lacpdu, slave, skb->len);
2582 }
2583 
2584 /**
2585  * bond_3ad_update_lacp_rate - change the lacp rate
2586  * @bond - bonding struct
2587  *
2588  * When modify lacp_rate parameter via sysfs,
2589  * update actor_oper_port_state of each port.
2590  *
2591  * Hold bond->mode_lock,
2592  * so we can modify port->actor_oper_port_state,
2593  * no matter bond is up or down.
2594  */
2595 void bond_3ad_update_lacp_rate(struct bonding *bond)
2596 {
2597 	struct port *port = NULL;
2598 	struct list_head *iter;
2599 	struct slave *slave;
2600 	int lacp_fast;
2601 
2602 	lacp_fast = bond->params.lacp_fast;
2603 	spin_lock_bh(&bond->mode_lock);
2604 	bond_for_each_slave(bond, slave, iter) {
2605 		port = &(SLAVE_AD_INFO(slave)->port);
2606 		if (lacp_fast)
2607 			port->actor_oper_port_state |= AD_STATE_LACP_TIMEOUT;
2608 		else
2609 			port->actor_oper_port_state &= ~AD_STATE_LACP_TIMEOUT;
2610 	}
2611 	spin_unlock_bh(&bond->mode_lock);
2612 }
2613