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