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