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