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