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