xref: /openbmc/linux/drivers/net/bonding/bond_3ad.c (revision 9c807965)
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  */
__get_bond_by_port(struct port * port)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(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  */
__get_first_agg(struct port * port)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  */
__agg_has_partner(struct aggregator * agg)169 static inline int __agg_has_partner(struct aggregator *agg)
170 {
171 	return !is_zero_ether_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  */
__disable_port(struct port * port)178 static inline void __disable_port(struct port *port)
179 {
180 	bond_set_slave_inactive_flags(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  */
__enable_port(struct port * port)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  */
__port_is_enabled(struct port * port)199 static inline int __port_is_enabled(struct port *port)
200 {
201 	return bond_is_active_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  */
__get_agg_selection_mode(struct port * port)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  */
__check_agg_selection_timer(struct port * port)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(&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  */
__get_link_speed(struct port * port)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  */
__get_duplex(struct port * port)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 
__ad_actor_update_port(struct port * port)386 static void __ad_actor_update_port(struct port *port)
387 {
388 	const struct bonding *bond = bond_get_bond_by_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  */
__ad_timer_to_ticks(u16 timer_type,u16 par)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  */
__choose_matched(struct lacpdu * lacpdu,struct port * port)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  */
__record_pdu(struct lacpdu * lacpdu,struct port * port)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  */
__record_default(struct port * port)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  */
__update_selected(struct lacpdu * lacpdu,struct port * port)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  */
__update_default_selected(struct port * port)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  */
__update_ntt(struct lacpdu * lacpdu,struct port * port)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  */
__agg_ports_are_ready(struct aggregator * aggregator)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  */
__set_agg_ports_ready(struct aggregator * aggregator,int val)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 
__agg_active_ports(struct aggregator * agg)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  */
__get_agg_bandwidth(struct aggregator * aggregator)707 static u32 __get_agg_bandwidth(struct aggregator *aggregator)
708 {
709 	int nports = __agg_active_ports(aggregator);
710 	u32 bandwidth = 0;
711 
712 	if (nports) {
713 		switch (__get_link_speed(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  */
__get_active_agg(struct aggregator * aggregator)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  */
__update_lacpdu_from_port(struct port * port)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  */
ad_lacpdu_send(struct port * port)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(&SLAVE_AD_INFO(slave)->stats.lacpdu_tx);
861 	atomic64_inc(&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, length);
870 
871 	ether_addr_copy(lacpdu_header->hdr.h_dest, 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(lacpdu_header->hdr.h_source, 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  */
ad_marker_send(struct port * port,struct bond_marker * marker)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 + 16);
901 	if (!skb)
902 		return -ENOMEM;
903 
904 	switch (marker->tlv_type) {
905 	case AD_MARKER_INFORMATION_SUBTYPE:
906 		atomic64_inc(&SLAVE_AD_INFO(slave)->stats.marker_tx);
907 		atomic64_inc(&BOND_AD_INFO(slave->bond).stats.marker_tx);
908 		break;
909 	case AD_MARKER_RESPONSE_SUBTYPE:
910 		atomic64_inc(&SLAVE_AD_INFO(slave)->stats.marker_resp_tx);
911 		atomic64_inc(&BOND_AD_INFO(slave->bond).stats.marker_resp_tx);
912 		break;
913 	}
914 
915 	skb_reserve(skb, 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, length);
923 
924 	ether_addr_copy(marker_header->hdr.h_dest, 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(marker_header->hdr.h_source, 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  */
ad_mux_machine(struct port * port,bool * update_slave_arr)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(port->aggregator, __agg_ports_are_ready(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(port->aggregator, __agg_ports_are_ready(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(port->aggregator, __agg_ports_are_ready(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(AD_WAIT_WHILE_TIMER, 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  */
ad_rx_machine(struct lacpdu * lacpdu,struct port * port)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(&SLAVE_AD_INFO(port->slave)->stats.lacpdu_rx);
1111 		atomic64_inc(&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(AD_CURRENT_WHILE_TIMER, (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(AD_CURRENT_WHILE_TIMER, (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  */
ad_churn_machine(struct port * port)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(AD_ACTOR_CHURN_TIMER, 0);
1246 		port->sm_churn_partner_timer_counter =
1247 			 __ad_timer_to_ticks(AD_PARTNER_CHURN_TIMER, 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  */
ad_tx_machine(struct port * port)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  */
ad_periodic_machine(struct port * port,struct bond_params * bond_params)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(AD_PERIODIC_TIMER, (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(AD_PERIODIC_TIMER, (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  */
ad_port_selection_logic(struct port * port,bool * update_slave_arr)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(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(port->aggregator,
1560 			      __agg_ports_are_ready(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  */
ad_agg_selection_test(struct aggregator * best,struct aggregator * curr)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(curr) && !__agg_has_partner(best))
1609 		return curr;
1610 
1611 	if (!__agg_has_partner(curr) && __agg_has_partner(best))
1612 		return best;
1613 
1614 	switch (__get_agg_selection_mode(curr->lag_ports)) {
1615 	case BOND_AD_COUNT:
1616 		if (__agg_active_ports(curr) > __agg_active_ports(best))
1617 			return curr;
1618 
1619 		if (__agg_active_ports(curr) < __agg_active_ports(best))
1620 			return best;
1621 
1622 		fallthrough;
1623 	case BOND_AD_STABLE:
1624 	case BOND_AD_BANDWIDTH:
1625 		if (__get_agg_bandwidth(curr) > __get_agg_bandwidth(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 
agg_device_up(const struct aggregator * agg)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(port->slave->dev) &&
1651 		    netif_carrier_ok(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  */
ad_agg_selection_logic(struct aggregator * agg,bool * update_slave_arr)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(agg);
1696 	best = (active && agg_device_up(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, agg);
1705 	}
1706 
1707 	if (best &&
1708 	    __get_agg_selection_mode(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(active) &&
1716 		    (__agg_has_partner(active) ||
1717 		     (!__agg_has_partner(active) &&
1718 		     !__agg_has_partner(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(origin);
1787 
1788 	if (active) {
1789 		if (!__agg_has_partner(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  */
ad_clear_agg(struct aggregator * aggregator)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(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  */
ad_initialize_agg(struct aggregator * aggregator)1832 static void ad_initialize_agg(struct aggregator *aggregator)
1833 {
1834 	if (aggregator) {
1835 		ad_clear_agg(aggregator);
1836 
1837 		eth_zero_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  */
ad_initialize_port(struct port * port,int lacp_fast)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  */
ad_enable_collecting_distributing(struct port * port,bool * update_slave_arr)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  */
ad_disable_collecting_distributing(struct port * port,bool * update_slave_arr)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  */
ad_marker_info_received(struct bond_marker * marker_info,struct port * port)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(&SLAVE_AD_INFO(port->slave)->stats.marker_rx);
1962 	atomic64_inc(&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) >= 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  */
ad_marker_response_received(struct bond_marker * marker,struct port * port)1985 static void ad_marker_response_received(struct bond_marker *marker,
1986 					struct port *port)
1987 {
1988 	atomic64_inc(&SLAVE_AD_INFO(port->slave)->stats.marker_resp_rx);
1989 	atomic64_inc(&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  */
bond_3ad_initiate_agg_selection(struct bonding * bond,int timeout)2008 void bond_3ad_initiate_agg_selection(struct bonding *bond, int timeout)
2009 {
2010 	atomic_set(&BOND_AD_INFO(bond).agg_select_timer, 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  */
bond_3ad_initialize(struct bonding * bond)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(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  */
bond_3ad_bind_slave(struct slave * slave)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, 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, 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  */
bond_3ad_unbind_slave(struct slave * slave)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(&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(__get_first_agg(port),
2189 							       &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(temp_aggregator,
2205 							       &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(temp_aggregator) == 0) {
2230 					select_new_active_agg = temp_aggregator->is_active;
2231 					if (temp_aggregator->num_of_ports == 0)
2232 						ad_clear_agg(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(__get_first_agg(port),
2237 							               &dummy_slave_update);
2238 					}
2239 				}
2240 				break;
2241 			}
2242 		}
2243 	}
2244 	port->slave = NULL;
2245 
2246 out:
2247 	spin_unlock_bh(&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  */
bond_3ad_update_ad_actor_settings(struct bonding * bond)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(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(&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(&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  */
bond_agg_timer_advance(struct bonding * bond)2288 static bool bond_agg_timer_advance(struct bonding *bond)
2289 {
2290 	int val, nval;
2291 
2292 	while (1) {
2293 		val = atomic_read(&BOND_AD_INFO(bond).agg_select_timer);
2294 		if (!val)
2295 			return false;
2296 		nval = val - 1;
2297 		if (atomic_cmpxchg(&BOND_AD_INFO(bond).agg_select_timer,
2298 				   val, 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  */
bond_3ad_state_machine_handler(struct work_struct * work)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(&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(aggregator, &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);
2368 		ad_port_selection_logic(port, &update_slave_arr);
2369 		ad_mux_machine(port, &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(&bond->mode_lock);
2387 
2388 	if (update_slave_arr)
2389 		bond_slave_arr_work_rearm(bond, 0);
2390 
2391 	if (should_notify_rtnl && rtnl_trylock()) {
2392 		bond_slave_state_notify(bond);
2393 		rtnl_unlock();
2394 	}
2395 	queue_delayed_work(bond->wq, &bond->ad_work, 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  */
bond_3ad_rx_indication(struct lacpdu * lacpdu,struct slave * slave)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(&slave->bond->mode_lock);
2430 		ad_rx_machine(lacpdu, port);
2431 		spin_unlock(&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, 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(stat);
2455 			stat = &BOND_AD_INFO(bond).stats.marker_unknown_rx;
2456 			atomic64_inc(stat);
2457 		}
2458 		break;
2459 	default:
2460 		atomic64_inc(&SLAVE_AD_INFO(slave)->stats.lacpdu_unknown_rx);
2461 		atomic64_inc(&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  */
ad_update_actor_keys(struct port * port,bool reset)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  */
bond_3ad_adapter_speed_duplex_changed(struct slave * slave)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(&slave->bond->mode_lock);
2536 	ad_update_actor_keys(port, false);
2537 	spin_unlock_bh(&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  */
bond_3ad_handle_link_change(struct slave * slave,char link)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(&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, false);
2574 	} else {
2575 		/* link has failed */
2576 		port->is_enabled = false;
2577 		ad_update_actor_keys(port, true);
2578 	}
2579 	agg = __get_first_agg(port);
2580 	ad_agg_selection_logic(agg, &dummy);
2581 
2582 	spin_unlock_bh(&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(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  */
bond_3ad_set_carrier(struct bonding * bond)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(&(SLAVE_AD_INFO(first_slave)->aggregator));
2620 	if (active) {
2621 		/* are enough slaves available to consider link up? */
2622 		if (__agg_active_ports(active) < bond->params.min_links) {
2623 			if (netif_carrier_ok(bond->dev)) {
2624 				netif_carrier_off(bond->dev);
2625 				goto out;
2626 			}
2627 		} else if (!netif_carrier_ok(bond->dev)) {
2628 			netif_carrier_on(bond->dev);
2629 			goto out;
2630 		}
2631 	} else if (netif_carrier_ok(bond->dev)) {
2632 		netif_carrier_off(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  */
__bond_3ad_get_active_agg_info(struct bonding * bond,struct ad_info * ad_info)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(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(ad_info->partner_system,
2671 			aggregator->partner_system.mac_addr_value);
2672 	return 0;
2673 }
2674 
bond_3ad_get_active_agg_info(struct bonding * bond,struct ad_info * ad_info)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 
bond_3ad_lacpdu_recv(const struct sk_buff * skb,struct bonding * bond,struct slave * slave)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, 0, sizeof(_lacpdu), &_lacpdu);
2698 	if (!lacpdu) {
2699 		atomic64_inc(&SLAVE_AD_INFO(slave)->stats.lacpdu_illegal_rx);
2700 		atomic64_inc(&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  */
bond_3ad_update_lacp_rate(struct bonding * bond)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(&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(&bond->mode_lock);
2735 }
2736 
bond_3ad_stats_size(void)2737 size_t bond_3ad_stats_size(void)
2738 {
2739 	return nla_total_size_64bit(sizeof(u64)) + /* BOND_3AD_STAT_LACPDU_RX */
2740 	       nla_total_size_64bit(sizeof(u64)) + /* BOND_3AD_STAT_LACPDU_TX */
2741 	       nla_total_size_64bit(sizeof(u64)) + /* BOND_3AD_STAT_LACPDU_UNKNOWN_RX */
2742 	       nla_total_size_64bit(sizeof(u64)) + /* BOND_3AD_STAT_LACPDU_ILLEGAL_RX */
2743 	       nla_total_size_64bit(sizeof(u64)) + /* BOND_3AD_STAT_MARKER_RX */
2744 	       nla_total_size_64bit(sizeof(u64)) + /* BOND_3AD_STAT_MARKER_TX */
2745 	       nla_total_size_64bit(sizeof(u64)) + /* BOND_3AD_STAT_MARKER_RESP_RX */
2746 	       nla_total_size_64bit(sizeof(u64)) + /* BOND_3AD_STAT_MARKER_RESP_TX */
2747 	       nla_total_size_64bit(sizeof(u64)); /* BOND_3AD_STAT_MARKER_UNKNOWN_RX */
2748 }
2749 
bond_3ad_stats_fill(struct sk_buff * skb,struct bond_3ad_stats * stats)2750 int bond_3ad_stats_fill(struct sk_buff *skb, struct bond_3ad_stats *stats)
2751 {
2752 	u64 val;
2753 
2754 	val = atomic64_read(&stats->lacpdu_rx);
2755 	if (nla_put_u64_64bit(skb, BOND_3AD_STAT_LACPDU_RX, val,
2756 			      BOND_3AD_STAT_PAD))
2757 		return -EMSGSIZE;
2758 	val = atomic64_read(&stats->lacpdu_tx);
2759 	if (nla_put_u64_64bit(skb, BOND_3AD_STAT_LACPDU_TX, val,
2760 			      BOND_3AD_STAT_PAD))
2761 		return -EMSGSIZE;
2762 	val = atomic64_read(&stats->lacpdu_unknown_rx);
2763 	if (nla_put_u64_64bit(skb, BOND_3AD_STAT_LACPDU_UNKNOWN_RX, val,
2764 			      BOND_3AD_STAT_PAD))
2765 		return -EMSGSIZE;
2766 	val = atomic64_read(&stats->lacpdu_illegal_rx);
2767 	if (nla_put_u64_64bit(skb, BOND_3AD_STAT_LACPDU_ILLEGAL_RX, val,
2768 			      BOND_3AD_STAT_PAD))
2769 		return -EMSGSIZE;
2770 
2771 	val = atomic64_read(&stats->marker_rx);
2772 	if (nla_put_u64_64bit(skb, BOND_3AD_STAT_MARKER_RX, val,
2773 			      BOND_3AD_STAT_PAD))
2774 		return -EMSGSIZE;
2775 	val = atomic64_read(&stats->marker_tx);
2776 	if (nla_put_u64_64bit(skb, BOND_3AD_STAT_MARKER_TX, val,
2777 			      BOND_3AD_STAT_PAD))
2778 		return -EMSGSIZE;
2779 	val = atomic64_read(&stats->marker_resp_rx);
2780 	if (nla_put_u64_64bit(skb, BOND_3AD_STAT_MARKER_RESP_RX, val,
2781 			      BOND_3AD_STAT_PAD))
2782 		return -EMSGSIZE;
2783 	val = atomic64_read(&stats->marker_resp_tx);
2784 	if (nla_put_u64_64bit(skb, BOND_3AD_STAT_MARKER_RESP_TX, val,
2785 			      BOND_3AD_STAT_PAD))
2786 		return -EMSGSIZE;
2787 	val = atomic64_read(&stats->marker_unknown_rx);
2788 	if (nla_put_u64_64bit(skb, BOND_3AD_STAT_MARKER_UNKNOWN_RX, val,
2789 			      BOND_3AD_STAT_PAD))
2790 		return -EMSGSIZE;
2791 
2792 	return 0;
2793 }
2794