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