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