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