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