drivers/net/bonding/bond_3ad.c

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