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