drivers/net/bonding/rte_eth_bond_8023ad.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2015 Intel Corporation
   3  */
   4
   5 #include <stddef.h>
   6 #include <string.h>
   7 #include <stdbool.h>
   8
   9 #include <rte_alarm.h>
  10 #include <rte_malloc.h>
  11 #include <rte_errno.h>
  12 #include <rte_cycles.h>
  13 #include <rte_compat.h>
  14
  15 #include "rte_eth_bond_private.h"
  16
  17 static void bond_mode_8023ad_ext_periodic_cb(void *arg);
  18 #ifdef RTE_LIBRTE_BOND_DEBUG_8023AD
  19
  20 #define MODE4_DEBUG(fmt, ...)                           \
  21         rte_log(RTE_LOG_DEBUG, bond_logtype,            \
  22                 "%6u [Port %u: %s] " fmt,               \
  23                 bond_dbg_get_time_diff_ms(), slave_id,  \
  24                 __func__, ##__VA_ARGS__)
  25
  26 static uint64_t start_time;
  27
  28 static unsigned
  29 bond_dbg_get_time_diff_ms(void)
  30 {
  31         uint64_t now;
  32
  33         now = rte_rdtsc();
  34         if (start_time == 0)
  35                 start_time = now;
  36
  37         return ((now - start_time) * 1000) / rte_get_tsc_hz();
  38 }
  39
  40 static void
  41 bond_print_lacp(struct lacpdu *l)
  42 {
  43         char a_address[18];
  44         char p_address[18];
  45         char a_state[256] = { 0 };
  46         char p_state[256] = { 0 };
  47
  48         static const char * const state_labels[] = {
  49                 "ACT", "TIMEOUT", "AGG", "SYNC", "COL", "DIST", "DEF", "EXP"
  50         };
  51
  52         int a_len = 0;
  53         int p_len = 0;
  54         uint8_t i;
  55         uint8_t *addr;
  56
  57         addr = l->actor.port_params.system.addr_bytes;
  58         snprintf(a_address, sizeof(a_address), "%02X:%02X:%02X:%02X:%02X:%02X",
  59                 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
  60
  61         addr = l->partner.port_params.system.addr_bytes;
  62         snprintf(p_address, sizeof(p_address), "%02X:%02X:%02X:%02X:%02X:%02X",
  63                 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
  64
  65         for (i = 0; i < 8; i++) {
  66                 if ((l->actor.state >> i) & 1) {
  67                         a_len += snprintf(&a_state[a_len], RTE_DIM(a_state) - a_len, "%s ",
  68                                 state_labels[i]);
  69                 }
  70
  71                 if ((l->partner.state >> i) & 1) {
  72                         p_len += snprintf(&p_state[p_len], RTE_DIM(p_state) - p_len, "%s ",
  73                                 state_labels[i]);
  74                 }
  75         }
  76
  77         if (a_len && a_state[a_len-1] == ' ')
  78                 a_state[a_len-1] = '\0';
  79
  80         if (p_len && p_state[p_len-1] == ' ')
  81                 p_state[p_len-1] = '\0';
  82
  83         RTE_BOND_LOG(DEBUG,
  84                      "LACP: {\n"
  85                      "  subtype= %02X\n"
  86                      "  ver_num=%02X\n"
  87                      "  actor={ tlv=%02X, len=%02X\n"
  88                      "    pri=%04X, system=%s, key=%04X, p_pri=%04X p_num=%04X\n"
  89                      "       state={ %s }\n"
  90                      "  }\n"
  91                      "  partner={ tlv=%02X, len=%02X\n"
  92                      "    pri=%04X, system=%s, key=%04X, p_pri=%04X p_num=%04X\n"
  93                      "       state={ %s }\n"
  94                      "  }\n"
  95                      "  collector={info=%02X, length=%02X, max_delay=%04X\n, "
  96                      "type_term=%02X, terminator_length = %02X }",
  97                      l->subtype,
  98                      l->version_number,
  99                      l->actor.tlv_type_info,
 100                      l->actor.info_length,
 101                      l->actor.port_params.system_priority,
 102                      a_address,
 103                      l->actor.port_params.key,
 104                      l->actor.port_params.port_priority,
 105                      l->actor.port_params.port_number,
 106                      a_state,
 107                      l->partner.tlv_type_info,
 108                      l->partner.info_length,
 109                      l->partner.port_params.system_priority,
 110                      p_address,
 111                      l->partner.port_params.key,
 112                      l->partner.port_params.port_priority,
 113                      l->partner.port_params.port_number,
 114                      p_state,
 115                      l->tlv_type_collector_info,
 116                      l->collector_info_length,
 117                      l->collector_max_delay,
 118                      l->tlv_type_terminator,
 119                      l->terminator_length);
 120
 121 }
 122
 123 #define BOND_PRINT_LACP(lacpdu) bond_print_lacp(lacpdu)
 124 #else
 125 #define BOND_PRINT_LACP(lacpdu) do { } while (0)
 126 #define MODE4_DEBUG(fmt, ...) do { } while (0)
 127 #endif
 128
 129 static const struct rte_ether_addr lacp_mac_addr = {
 130         .addr_bytes = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x02 }
 131 };
 132
 133 struct port bond_mode_8023ad_ports[RTE_MAX_ETHPORTS];
 134
 135 static void
 136 timer_cancel(uint64_t *timer)
 137 {
 138         *timer = 0;
 139 }
 140
 141 static void
 142 timer_set(uint64_t *timer, uint64_t timeout)
 143 {
 144         *timer = rte_rdtsc() + timeout;
 145 }
 146
 147 /* Forces given timer to be in expired state. */
 148 static void
 149 timer_force_expired(uint64_t *timer)
 150 {
 151         *timer = rte_rdtsc();
 152 }
 153
 154 static bool
 155 timer_is_stopped(uint64_t *timer)
 156 {
 157         return *timer == 0;
 158 }
 159
 160 static bool
 161 timer_is_expired(uint64_t *timer)
 162 {
 163         return *timer < rte_rdtsc();
 164 }
 165
 166 /* Timer is in running state if it is not stopped nor expired */
 167 static bool
 168 timer_is_running(uint64_t *timer)
 169 {
 170         return !timer_is_stopped(timer) && !timer_is_expired(timer);
 171 }
 172
 173 static void
 174 set_warning_flags(struct port *port, uint16_t flags)
 175 {
 176         int retval;
 177         uint16_t old;
 178         uint16_t new_flag = 0;
 179
 180         do {
 181                 old = port->warnings_to_show;
 182                 new_flag = old | flags;
 183                 retval = rte_atomic16_cmpset(&port->warnings_to_show, old, new_flag);
 184         } while (unlikely(retval == 0));
 185 }
 186
 187 static void
 188 show_warnings(uint16_t slave_id)
 189 {
 190         struct port *port = &bond_mode_8023ad_ports[slave_id];
 191         uint8_t warnings;
 192
 193         do {
 194                 warnings = port->warnings_to_show;
 195         } while (rte_atomic16_cmpset(&port->warnings_to_show, warnings, 0) == 0);
 196
 197         if (!warnings)
 198                 return;
 199
 200         if (!timer_is_expired(&port->warning_timer))
 201                 return;
 202
 203
 204         timer_set(&port->warning_timer, BOND_8023AD_WARNINGS_PERIOD_MS *
 205                         rte_get_tsc_hz() / 1000);
 206
 207         if (warnings & WRN_RX_QUEUE_FULL) {
 208                 RTE_BOND_LOG(DEBUG,
 209                              "Slave %u: failed to enqueue LACP packet into RX ring.\n"
 210                              "Receive and transmit functions must be invoked on bonded"
 211                              "interface at least 10 times per second or LACP will notwork correctly",
 212                              slave_id);
 213         }
 214
 215         if (warnings & WRN_TX_QUEUE_FULL) {
 216                 RTE_BOND_LOG(DEBUG,
 217                              "Slave %u: failed to enqueue LACP packet into TX ring.\n"
 218                              "Receive and transmit functions must be invoked on bonded"
 219                              "interface at least 10 times per second or LACP will not work correctly",
 220                              slave_id);
 221         }
 222
 223         if (warnings & WRN_RX_MARKER_TO_FAST)
 224                 RTE_BOND_LOG(INFO, "Slave %u: marker to early - ignoring.",
 225                              slave_id);
 226
 227         if (warnings & WRN_UNKNOWN_SLOW_TYPE) {
 228                 RTE_BOND_LOG(INFO,
 229                         "Slave %u: ignoring unknown slow protocol frame type",
 230                              slave_id);
 231         }
 232
 233         if (warnings & WRN_UNKNOWN_MARKER_TYPE)
 234                 RTE_BOND_LOG(INFO, "Slave %u: ignoring unknown marker type",
 235                              slave_id);
 236
 237         if (warnings & WRN_NOT_LACP_CAPABLE)
 238                 MODE4_DEBUG("Port %u is not LACP capable!\n", slave_id);
 239 }
 240
 241 static void
 242 record_default(struct port *port)
 243 {
 244         /* Record default parameters for partner. Partner admin parameters
 245          * are not implemented so set them to arbitrary default (last known) and
 246          * mark actor that parner is in defaulted state. */
 247         port->partner_state = STATE_LACP_ACTIVE;
 248         ACTOR_STATE_SET(port, DEFAULTED);
 249 }
 250
 251 /** Function handles rx state machine.
 252  *
 253  * This function implements Receive State Machine from point 5.4.12 in
 254  * 802.1AX documentation. It should be called periodically.
 255  *
 256  * @param lacpdu                LACPDU received.
 257  * @param port                  Port on which LACPDU was received.
 258  */
 259 static void
 260 rx_machine(struct bond_dev_private *internals, uint16_t slave_id,
 261                 struct lacpdu *lacp)
 262 {
 263         struct port *agg, *port = &bond_mode_8023ad_ports[slave_id];
 264         uint64_t timeout;
 265
 266         if (SM_FLAG(port, BEGIN)) {
 267                 /* Initialize stuff */
 268                 MODE4_DEBUG("-> INITIALIZE\n");
 269                 SM_FLAG_CLR(port, MOVED);
 270                 port->selected = UNSELECTED;
 271
 272                 record_default(port);
 273
 274                 ACTOR_STATE_CLR(port, EXPIRED);
 275                 timer_cancel(&port->current_while_timer);
 276
 277                 /* DISABLED: On initialization partner is out of sync */
 278                 PARTNER_STATE_CLR(port, SYNCHRONIZATION);
 279
 280                 /* LACP DISABLED stuff if LACP not enabled on this port */
 281                 if (!SM_FLAG(port, LACP_ENABLED))
 282                         PARTNER_STATE_CLR(port, AGGREGATION);
 283                 else
 284                         PARTNER_STATE_SET(port, AGGREGATION);
 285         }
 286
 287         if (!SM_FLAG(port, LACP_ENABLED)) {
 288                 /* Update parameters only if state changed */
 289                 if (!timer_is_stopped(&port->current_while_timer)) {
 290                         port->selected = UNSELECTED;
 291                         record_default(port);
 292                         PARTNER_STATE_CLR(port, AGGREGATION);
 293                         ACTOR_STATE_CLR(port, EXPIRED);
 294                         timer_cancel(&port->current_while_timer);
 295                 }
 296                 return;
 297         }
 298
 299         if (lacp) {
 300                 MODE4_DEBUG("LACP -> CURRENT\n");
 301                 BOND_PRINT_LACP(lacp);
 302                 /* Update selected flag. If partner parameters are defaulted assume they
 303                  * are match. If not defaulted  compare LACP actor with ports parner
 304                  * params. */
 305                 if (!ACTOR_STATE(port, DEFAULTED) &&
 306                         (ACTOR_STATE(port, AGGREGATION) != PARTNER_STATE(port, AGGREGATION)
 307                         || memcmp(&port->partner, &lacp->actor.port_params,
 308                                 sizeof(port->partner)) != 0)) {
 309                         MODE4_DEBUG("selected <- UNSELECTED\n");
 310                         port->selected = UNSELECTED;
 311                 }
 312
 313                 /* Record this PDU actor params as partner params */
 314                 memcpy(&port->partner, &lacp->actor.port_params,
 315                         sizeof(struct port_params));
 316                 port->partner_state = lacp->actor.state;
 317
 318                 /* Partner parameters are not defaulted any more */
 319                 ACTOR_STATE_CLR(port, DEFAULTED);
 320
 321                 /* If LACP partner params match this port actor params */
 322                 agg = &bond_mode_8023ad_ports[port->aggregator_port_id];
 323                 bool match = port->actor.system_priority ==
 324                         lacp->partner.port_params.system_priority &&
 325                         is_same_ether_addr(&agg->actor.system,
 326                         &lacp->partner.port_params.system) &&
 327                         port->actor.port_priority ==
 328                         lacp->partner.port_params.port_priority &&
 329                         port->actor.port_number ==
 330                         lacp->partner.port_params.port_number;
 331
 332                 /* Update NTT if partners information are outdated (xored and masked
 333                  * bits are set)*/
 334                 uint8_t state_mask = STATE_LACP_ACTIVE | STATE_LACP_SHORT_TIMEOUT |
 335                         STATE_SYNCHRONIZATION | STATE_AGGREGATION;
 336
 337                 if (((port->actor_state ^ lacp->partner.state) & state_mask) ||
 338                                 match == false) {
 339                         SM_FLAG_SET(port, NTT);
 340                 }
 341
 342                 /* If LACP partner params match this port actor params */
 343                 if (match == true && ACTOR_STATE(port, AGGREGATION) ==
 344                                 PARTNER_STATE(port,     AGGREGATION))
 345                         PARTNER_STATE_SET(port, SYNCHRONIZATION);
 346                 else if (!PARTNER_STATE(port, AGGREGATION) && ACTOR_STATE(port,
 347                                 AGGREGATION))
 348                         PARTNER_STATE_SET(port, SYNCHRONIZATION);
 349                 else
 350                         PARTNER_STATE_CLR(port, SYNCHRONIZATION);
 351
 352                 if (ACTOR_STATE(port, LACP_SHORT_TIMEOUT))
 353                         timeout = internals->mode4.short_timeout;
 354                 else
 355                         timeout = internals->mode4.long_timeout;
 356
 357                 timer_set(&port->current_while_timer, timeout);
 358                 ACTOR_STATE_CLR(port, EXPIRED);
 359                 return; /* No state change */
 360         }
 361
 362         /* If CURRENT state timer is not running (stopped or expired)
 363          * transit to EXPIRED state from DISABLED or CURRENT */
 364         if (!timer_is_running(&port->current_while_timer)) {
 365                 ACTOR_STATE_SET(port, EXPIRED);
 366                 PARTNER_STATE_CLR(port, SYNCHRONIZATION);
 367                 PARTNER_STATE_SET(port, LACP_SHORT_TIMEOUT);
 368                 timer_set(&port->current_while_timer, internals->mode4.short_timeout);
 369         }
 370 }
 371
 372 /**
 373  * Function handles periodic tx state machine.
 374  *
 375  * Function implements Periodic Transmission state machine from point 5.4.13
 376  * in 802.1AX documentation. It should be called periodically.
 377  *
 378  * @param port                  Port to handle state machine.
 379  */
 380 static void
 381 periodic_machine(struct bond_dev_private *internals, uint16_t slave_id)
 382 {
 383         struct port *port = &bond_mode_8023ad_ports[slave_id];
 384         /* Calculate if either site is LACP enabled */
 385         uint64_t timeout;
 386         uint8_t active = ACTOR_STATE(port, LACP_ACTIVE) ||
 387                 PARTNER_STATE(port, LACP_ACTIVE);
 388
 389         uint8_t is_partner_fast, was_partner_fast;
 390         /* No periodic is on BEGIN, LACP DISABLE or when both sides are pasive */
 391         if (SM_FLAG(port, BEGIN) || !SM_FLAG(port, LACP_ENABLED) || !active) {
 392                 timer_cancel(&port->periodic_timer);
 393                 timer_force_expired(&port->tx_machine_timer);
 394                 SM_FLAG_CLR(port, PARTNER_SHORT_TIMEOUT);
 395
 396                 MODE4_DEBUG("-> NO_PERIODIC ( %s%s%s)\n",
 397                         SM_FLAG(port, BEGIN) ? "begind " : "",
 398                         SM_FLAG(port, LACP_ENABLED) ? "" : "LACP disabled ",
 399                         active ? "LACP active " : "LACP pasive ");
 400                 return;
 401         }
 402
 403         is_partner_fast = PARTNER_STATE(port, LACP_SHORT_TIMEOUT);
 404         was_partner_fast = SM_FLAG(port, PARTNER_SHORT_TIMEOUT);
 405
 406         /* If periodic timer is not started, transit from NO PERIODIC to FAST/SLOW.
 407          * Other case: check if timer expire or partners settings changed. */
 408         if (!timer_is_stopped(&port->periodic_timer)) {
 409                 if (timer_is_expired(&port->periodic_timer)) {
 410                         SM_FLAG_SET(port, NTT);
 411                 } else if (is_partner_fast != was_partner_fast) {
 412                         /* Partners timeout  was slow and now it is fast -> send LACP.
 413                          * In other case (was fast and now it is slow) just switch
 414                          * timeout to slow without forcing send of LACP (because standard
 415                          * say so)*/
 416                         if (is_partner_fast)
 417                                 SM_FLAG_SET(port, NTT);
 418                 } else
 419                         return; /* Nothing changed */
 420         }
 421
 422         /* Handle state transition to FAST/SLOW LACP timeout */
 423         if (is_partner_fast) {
 424                 timeout = internals->mode4.fast_periodic_timeout;
 425                 SM_FLAG_SET(port, PARTNER_SHORT_TIMEOUT);
 426         } else {
 427                 timeout = internals->mode4.slow_periodic_timeout;
 428                 SM_FLAG_CLR(port, PARTNER_SHORT_TIMEOUT);
 429         }
 430
 431         timer_set(&port->periodic_timer, timeout);
 432 }
 433
 434 /**
 435  * Function handles mux state machine.
 436  *
 437  * Function implements Mux Machine from point 5.4.15 in 802.1AX documentation.
 438  * It should be called periodically.
 439  *
 440  * @param port                  Port to handle state machine.
 441  */
 442 static void
 443 mux_machine(struct bond_dev_private *internals, uint16_t slave_id)
 444 {
 445         struct port *port = &bond_mode_8023ad_ports[slave_id];
 446
 447         /* Save current state for later use */
 448         const uint8_t state_mask = STATE_SYNCHRONIZATION | STATE_DISTRIBUTING |
 449                 STATE_COLLECTING;
 450
 451         /* Enter DETACHED state on BEGIN condition or from any other state if
 452          * port was unselected */
 453         if (SM_FLAG(port, BEGIN) ||
 454                         port->selected == UNSELECTED || (port->selected == STANDBY &&
 455                                 (port->actor_state & state_mask) != 0)) {
 456                 /* detach mux from aggregator */
 457                 port->actor_state &= ~state_mask;
 458                 /* Set ntt to true if BEGIN condition or transition from any other state
 459                  * which is indicated that wait_while_timer was started */
 460                 if (SM_FLAG(port, BEGIN) ||
 461                                 !timer_is_stopped(&port->wait_while_timer)) {
 462                         SM_FLAG_SET(port, NTT);
 463                         MODE4_DEBUG("-> DETACHED\n");
 464                 }
 465                 timer_cancel(&port->wait_while_timer);
 466         }
 467
 468         if (timer_is_stopped(&port->wait_while_timer)) {
 469                 if (port->selected == SELECTED || port->selected == STANDBY) {
 470                         timer_set(&port->wait_while_timer,
 471                                 internals->mode4.aggregate_wait_timeout);
 472
 473                         MODE4_DEBUG("DETACHED -> WAITING\n");
 474                 }
 475                 /* Waiting state entered */
 476                 return;
 477         }
 478
 479         /* Transit next state if port is ready */
 480         if (!timer_is_expired(&port->wait_while_timer))
 481                 return;
 482
 483         if ((ACTOR_STATE(port, DISTRIBUTING) || ACTOR_STATE(port, COLLECTING)) &&
 484                 !PARTNER_STATE(port, SYNCHRONIZATION)) {
 485                 /* If in COLLECTING or DISTRIBUTING state and partner becomes out of
 486                  * sync transit to ATACHED state.  */
 487                 ACTOR_STATE_CLR(port, DISTRIBUTING);
 488                 ACTOR_STATE_CLR(port, COLLECTING);
 489                 /* Clear actor sync to activate transit ATACHED in condition bellow */
 490                 ACTOR_STATE_CLR(port, SYNCHRONIZATION);
 491                 MODE4_DEBUG("Out of sync -> ATTACHED\n");
 492         }
 493
 494         if (!ACTOR_STATE(port, SYNCHRONIZATION)) {
 495                 /* attach mux to aggregator */
 496                 RTE_ASSERT((port->actor_state & (STATE_COLLECTING |
 497                         STATE_DISTRIBUTING)) == 0);
 498
 499                 ACTOR_STATE_SET(port, SYNCHRONIZATION);
 500                 SM_FLAG_SET(port, NTT);
 501                 MODE4_DEBUG("ATTACHED Entered\n");
 502         } else if (!ACTOR_STATE(port, COLLECTING)) {
 503                 /* Start collecting if in sync */
 504                 if (PARTNER_STATE(port, SYNCHRONIZATION)) {
 505                         MODE4_DEBUG("ATTACHED -> COLLECTING\n");
 506                         ACTOR_STATE_SET(port, COLLECTING);
 507                         SM_FLAG_SET(port, NTT);
 508                 }
 509         } else if (ACTOR_STATE(port, COLLECTING)) {
 510                 /* Check if partner is in COLLECTING state. If so this port can
 511                  * distribute frames to it */
 512                 if (!ACTOR_STATE(port, DISTRIBUTING)) {
 513                         if (PARTNER_STATE(port, COLLECTING)) {
 514                                 /* Enable  DISTRIBUTING if partner is collecting */
 515                                 ACTOR_STATE_SET(port, DISTRIBUTING);
 516                                 SM_FLAG_SET(port, NTT);
 517                                 MODE4_DEBUG("COLLECTING -> DISTRIBUTING\n");
 518                                 RTE_BOND_LOG(INFO,
 519                                         "Bond %u: slave id %u distributing started.",
 520                                         internals->port_id, slave_id);
 521                         }
 522                 } else {
 523                         if (!PARTNER_STATE(port, COLLECTING)) {
 524                                 /* Disable DISTRIBUTING (enter COLLECTING state) if partner
 525                                  * is not collecting */
 526                                 ACTOR_STATE_CLR(port, DISTRIBUTING);
 527                                 SM_FLAG_SET(port, NTT);
 528                                 MODE4_DEBUG("DISTRIBUTING -> COLLECTING\n");
 529                                 RTE_BOND_LOG(INFO,
 530                                         "Bond %u: slave id %u distributing stopped.",
 531                                         internals->port_id, slave_id);
 532                         }
 533                 }
 534         }
 535 }
 536
 537 /**
 538  * Function handles transmit state machine.
 539  *
 540  * Function implements Transmit Machine from point 5.4.16 in 802.1AX
 541  * documentation.
 542  *
 543  * @param port
 544  */
 545 static void
 546 tx_machine(struct bond_dev_private *internals, uint16_t slave_id)
 547 {
 548         struct port *agg, *port = &bond_mode_8023ad_ports[slave_id];
 549
 550         struct rte_mbuf *lacp_pkt = NULL;
 551         struct lacpdu_header *hdr;
 552         struct lacpdu *lacpdu;
 553
 554         /* If periodic timer is not running periodic machine is in NO PERIODIC and
 555          * according to 802.3ax standard tx machine should not transmit any frames
 556          * and set ntt to false. */
 557         if (timer_is_stopped(&port->periodic_timer))
 558                 SM_FLAG_CLR(port, NTT);
 559
 560         if (!SM_FLAG(port, NTT))
 561                 return;
 562
 563         if (!timer_is_expired(&port->tx_machine_timer))
 564                 return;
 565
 566         lacp_pkt = rte_pktmbuf_alloc(port->mbuf_pool);
 567         if (lacp_pkt == NULL) {
 568                 RTE_BOND_LOG(ERR, "Failed to allocate LACP packet from pool");
 569                 return;
 570         }
 571
 572         lacp_pkt->data_len = sizeof(*hdr);
 573         lacp_pkt->pkt_len = sizeof(*hdr);
 574
 575         hdr = rte_pktmbuf_mtod(lacp_pkt, struct lacpdu_header *);
 576
 577         /* Source and destination MAC */
 578         ether_addr_copy(&lacp_mac_addr, &hdr->eth_hdr.d_addr);
 579         rte_eth_macaddr_get(slave_id, &hdr->eth_hdr.s_addr);
 580         hdr->eth_hdr.ether_type = rte_cpu_to_be_16(ETHER_TYPE_SLOW);
 581
 582         lacpdu = &hdr->lacpdu;
 583         memset(lacpdu, 0, sizeof(*lacpdu));
 584
 585         /* Initialize LACP part */
 586         lacpdu->subtype = SLOW_SUBTYPE_LACP;
 587         lacpdu->version_number = 1;
 588
 589         /* ACTOR */
 590         lacpdu->actor.tlv_type_info = TLV_TYPE_ACTOR_INFORMATION;
 591         lacpdu->actor.info_length = sizeof(struct lacpdu_actor_partner_params);
 592         memcpy(&hdr->lacpdu.actor.port_params, &port->actor,
 593                         sizeof(port->actor));
 594         agg = &bond_mode_8023ad_ports[port->aggregator_port_id];
 595         ether_addr_copy(&agg->actor.system, &hdr->lacpdu.actor.port_params.system);
 596         lacpdu->actor.state = port->actor_state;
 597
 598         /* PARTNER */
 599         lacpdu->partner.tlv_type_info = TLV_TYPE_PARTNER_INFORMATION;
 600         lacpdu->partner.info_length = sizeof(struct lacpdu_actor_partner_params);
 601         memcpy(&lacpdu->partner.port_params, &port->partner,
 602                         sizeof(struct port_params));
 603         lacpdu->partner.state = port->partner_state;
 604
 605         /* Other fields */
 606         lacpdu->tlv_type_collector_info = TLV_TYPE_COLLECTOR_INFORMATION;
 607         lacpdu->collector_info_length = 0x10;
 608         lacpdu->collector_max_delay = 0;
 609
 610         lacpdu->tlv_type_terminator = TLV_TYPE_TERMINATOR_INFORMATION;
 611         lacpdu->terminator_length = 0;
 612
 613         MODE4_DEBUG("Sending LACP frame\n");
 614         BOND_PRINT_LACP(lacpdu);
 615
 616         if (internals->mode4.dedicated_queues.enabled == 0) {
 617                 int retval = rte_ring_enqueue(port->tx_ring, lacp_pkt);
 618                 if (retval != 0) {
 619                         /* If TX ring full, drop packet and free message.
 620                            Retransmission will happen in next function call. */
 621                         rte_pktmbuf_free(lacp_pkt);
 622                         set_warning_flags(port, WRN_TX_QUEUE_FULL);
 623                         return;
 624                 }
 625         } else {
 626                 uint16_t pkts_sent = rte_eth_tx_burst(slave_id,
 627                                 internals->mode4.dedicated_queues.tx_qid,
 628                                 &lacp_pkt, 1);
 629                 if (pkts_sent != 1) {
 630                         rte_pktmbuf_free(lacp_pkt);
 631                         set_warning_flags(port, WRN_TX_QUEUE_FULL);
 632                         return;
 633                 }
 634         }
 635
 636
 637         timer_set(&port->tx_machine_timer, internals->mode4.tx_period_timeout);
 638         SM_FLAG_CLR(port, NTT);
 639 }
 640
 641 static uint8_t
 642 max_index(uint64_t *a, int n)
 643 {
 644         if (n <= 0)
 645                 return -1;
 646
 647         int i, max_i = 0;
 648         uint64_t max = a[0];
 649
 650         for (i = 1; i < n; ++i) {
 651                 if (a[i] > max) {
 652                         max = a[i];
 653                         max_i = i;
 654                 }
 655         }
 656
 657         return max_i;
 658 }
 659
 660 /**
 661  * Function assigns port to aggregator.
 662  *
 663  * @param bond_dev_private      Pointer to bond_dev_private structure.
 664  * @param port_pos                      Port to assign.
 665  */
 666 static void
 667 selection_logic(struct bond_dev_private *internals, uint16_t slave_id)
 668 {
 669         struct port *agg, *port;
 670         uint16_t slaves_count, new_agg_id, i, j = 0;
 671         uint16_t *slaves;
 672         uint64_t agg_bandwidth[8] = {0};
 673         uint64_t agg_count[8] = {0};
 674         uint16_t default_slave = 0;
 675         uint8_t mode_count_id, mode_band_id;
 676         struct rte_eth_link link_info;
 677
 678         slaves = internals->active_slaves;
 679         slaves_count = internals->active_slave_count;
 680         port = &bond_mode_8023ad_ports[slave_id];
 681
 682         /* Search for aggregator suitable for this port */
 683         for (i = 0; i < slaves_count; ++i) {
 684                 agg = &bond_mode_8023ad_ports[slaves[i]];
 685                 /* Skip ports that are not aggreagators */
 686                 if (agg->aggregator_port_id != slaves[i])
 687                         continue;
 688
 689                 agg_count[agg->aggregator_port_id] += 1;
 690                 rte_eth_link_get_nowait(slaves[i], &link_info);
 691                 agg_bandwidth[agg->aggregator_port_id] += link_info.link_speed;
 692
 693                 /* Actors system ID is not checked since all slave device have the same
 694                  * ID (MAC address). */
 695                 if ((agg->actor.key == port->actor.key &&
 696                         agg->partner.system_priority == port->partner.system_priority &&
 697                         is_same_ether_addr(&agg->partner.system, &port->partner.system) == 1
 698                         && (agg->partner.key == port->partner.key)) &&
 699                         is_zero_ether_addr(&port->partner.system) != 1 &&
 700                         (agg->actor.key &
 701                                 rte_cpu_to_be_16(BOND_LINK_FULL_DUPLEX_KEY)) != 0) {
 702
 703                         if (j == 0)
 704                                 default_slave = i;
 705                         j++;
 706                 }
 707         }
 708
 709         switch (internals->mode4.agg_selection) {
 710         case AGG_COUNT:
 711                 mode_count_id = max_index(
 712                                 (uint64_t *)agg_count, slaves_count);
 713                 new_agg_id = mode_count_id;
 714                 break;
 715         case AGG_BANDWIDTH:
 716                 mode_band_id = max_index(
 717                                 (uint64_t *)agg_bandwidth, slaves_count);
 718                 new_agg_id = mode_band_id;
 719                 break;
 720         case AGG_STABLE:
 721                 if (default_slave == slaves_count)
 722                         new_agg_id = slave_id;
 723                 else
 724                         new_agg_id = slaves[default_slave];
 725                 break;
 726         default:
 727                 if (default_slave == slaves_count)
 728                         new_agg_id = slave_id;
 729                 else
 730                         new_agg_id = slaves[default_slave];
 731                 break;
 732         }
 733
 734         if (new_agg_id != port->aggregator_port_id) {
 735                 port->aggregator_port_id = new_agg_id;
 736
 737                 MODE4_DEBUG("-> SELECTED: ID=%3u\n"
 738                         "\t%s aggregator ID=%3u\n",
 739                         port->aggregator_port_id,
 740                         port->aggregator_port_id == slave_id ?
 741                                 "aggregator not found, using default" : "aggregator found",
 742                         port->aggregator_port_id);
 743         }
 744
 745         port->selected = SELECTED;
 746 }
 747
 748 /* Function maps DPDK speed to bonding speed stored in key field */
 749 static uint16_t
 750 link_speed_key(uint16_t speed) {
 751         uint16_t key_speed;
 752
 753         switch (speed) {
 754         case ETH_SPEED_NUM_NONE:
 755                 key_speed = 0x00;
 756                 break;
 757         case ETH_SPEED_NUM_10M:
 758                 key_speed = BOND_LINK_SPEED_KEY_10M;
 759                 break;
 760         case ETH_SPEED_NUM_100M:
 761                 key_speed = BOND_LINK_SPEED_KEY_100M;
 762                 break;
 763         case ETH_SPEED_NUM_1G:
 764                 key_speed = BOND_LINK_SPEED_KEY_1000M;
 765                 break;
 766         case ETH_SPEED_NUM_10G:
 767                 key_speed = BOND_LINK_SPEED_KEY_10G;
 768                 break;
 769         case ETH_SPEED_NUM_20G:
 770                 key_speed = BOND_LINK_SPEED_KEY_20G;
 771                 break;
 772         case ETH_SPEED_NUM_40G:
 773                 key_speed = BOND_LINK_SPEED_KEY_40G;
 774                 break;
 775         default:
 776                 /* Unknown speed*/
 777                 key_speed = 0xFFFF;
 778         }
 779
 780         return key_speed;
 781 }
 782
 783 static void
 784 rx_machine_update(struct bond_dev_private *internals, uint16_t slave_id,
 785                 struct rte_mbuf *lacp_pkt) {
 786         struct lacpdu_header *lacp;
 787         struct lacpdu_actor_partner_params *partner;
 788
 789         if (lacp_pkt != NULL) {
 790                 lacp = rte_pktmbuf_mtod(lacp_pkt, struct lacpdu_header *);
 791                 RTE_ASSERT(lacp->lacpdu.subtype == SLOW_SUBTYPE_LACP);
 792
 793                 partner = &lacp->lacpdu.partner;
 794                 if (is_same_ether_addr(&partner->port_params.system,
 795                         &internals->mode4.mac_addr)) {
 796                         /* This LACP frame is sending to the bonding port
 797                          * so pass it to rx_machine.
 798                          */
 799                         rx_machine(internals, slave_id, &lacp->lacpdu);
 800                 }
 801                 rte_pktmbuf_free(lacp_pkt);
 802         } else
 803                 rx_machine(internals, slave_id, NULL);
 804 }
 805
 806 static void
 807 bond_mode_8023ad_periodic_cb(void *arg)
 808 {
 809         struct rte_eth_dev *bond_dev = arg;
 810         struct bond_dev_private *internals = bond_dev->data->dev_private;
 811         struct port *port;
 812         struct rte_eth_link link_info;
 813         struct rte_ether_addr slave_addr;
 814         struct rte_mbuf *lacp_pkt = NULL;
 815         uint16_t slave_id;
 816         uint16_t i;
 817
 818
 819         /* Update link status on each port */
 820         for (i = 0; i < internals->active_slave_count; i++) {
 821                 uint16_t key;
 822
 823                 slave_id = internals->active_slaves[i];
 824                 rte_eth_link_get_nowait(slave_id, &link_info);
 825                 rte_eth_macaddr_get(slave_id, &slave_addr);
 826
 827                 if (link_info.link_status != 0) {
 828                         key = link_speed_key(link_info.link_speed) << 1;
 829                         if (link_info.link_duplex == ETH_LINK_FULL_DUPLEX)
 830                                 key |= BOND_LINK_FULL_DUPLEX_KEY;
 831                 } else
 832                         key = 0;
 833
 834                 port = &bond_mode_8023ad_ports[slave_id];
 835
 836                 key = rte_cpu_to_be_16(key);
 837                 if (key != port->actor.key) {
 838                         if (!(key & rte_cpu_to_be_16(BOND_LINK_FULL_DUPLEX_KEY)))
 839                                 set_warning_flags(port, WRN_NOT_LACP_CAPABLE);
 840
 841                         port->actor.key = key;
 842                         SM_FLAG_SET(port, NTT);
 843                 }
 844
 845                 if (!is_same_ether_addr(&port->actor.system, &slave_addr)) {
 846                         ether_addr_copy(&slave_addr, &port->actor.system);
 847                         if (port->aggregator_port_id == slave_id)
 848                                 SM_FLAG_SET(port, NTT);
 849                 }
 850         }
 851
 852         for (i = 0; i < internals->active_slave_count; i++) {
 853                 slave_id = internals->active_slaves[i];
 854                 port = &bond_mode_8023ad_ports[slave_id];
 855
 856                 if ((port->actor.key &
 857                                 rte_cpu_to_be_16(BOND_LINK_FULL_DUPLEX_KEY)) == 0) {
 858
 859                         SM_FLAG_SET(port, BEGIN);
 860
 861                         /* LACP is disabled on half duples or link is down */
 862                         if (SM_FLAG(port, LACP_ENABLED)) {
 863                                 /* If port was enabled set it to BEGIN state */
 864                                 SM_FLAG_CLR(port, LACP_ENABLED);
 865                                 ACTOR_STATE_CLR(port, DISTRIBUTING);
 866                                 ACTOR_STATE_CLR(port, COLLECTING);
 867                         }
 868
 869                         /* Skip this port processing */
 870                         continue;
 871                 }
 872
 873                 SM_FLAG_SET(port, LACP_ENABLED);
 874
 875                 if (internals->mode4.dedicated_queues.enabled == 0) {
 876                         /* Find LACP packet to this port. Do not check subtype,
 877                          * it is done in function that queued packet
 878                          */
 879                         int retval = rte_ring_dequeue(port->rx_ring,
 880                                         (void **)&lacp_pkt);
 881
 882                         if (retval != 0)
 883                                 lacp_pkt = NULL;
 884
 885                         rx_machine_update(internals, slave_id, lacp_pkt);
 886                 } else {
 887                         uint16_t rx_count = rte_eth_rx_burst(slave_id,
 888                                         internals->mode4.dedicated_queues.rx_qid,
 889                                         &lacp_pkt, 1);
 890
 891                         if (rx_count == 1)
 892                                 bond_mode_8023ad_handle_slow_pkt(internals,
 893                                                 slave_id, lacp_pkt);
 894                         else
 895                                 rx_machine_update(internals, slave_id, NULL);
 896                 }
 897
 898                 periodic_machine(internals, slave_id);
 899                 mux_machine(internals, slave_id);
 900                 tx_machine(internals, slave_id);
 901                 selection_logic(internals, slave_id);
 902
 903                 SM_FLAG_CLR(port, BEGIN);
 904                 show_warnings(slave_id);
 905         }
 906
 907         rte_eal_alarm_set(internals->mode4.update_timeout_us,
 908                         bond_mode_8023ad_periodic_cb, arg);
 909 }
 910
 911 void
 912 bond_mode_8023ad_activate_slave(struct rte_eth_dev *bond_dev,
 913                                 uint16_t slave_id)
 914 {
 915         struct bond_dev_private *internals = bond_dev->data->dev_private;
 916
 917         struct port *port = &bond_mode_8023ad_ports[slave_id];
 918         struct port_params initial = {
 919                         .system = { { 0 } },
 920                         .system_priority = rte_cpu_to_be_16(0xFFFF),
 921                         .key = rte_cpu_to_be_16(BOND_LINK_FULL_DUPLEX_KEY),
 922                         .port_priority = rte_cpu_to_be_16(0x00FF),
 923                         .port_number = 0,
 924         };
 925
 926         char mem_name[RTE_ETH_NAME_MAX_LEN];
 927         int socket_id;
 928         unsigned element_size;
 929         uint32_t total_tx_desc;
 930         struct bond_tx_queue *bd_tx_q;
 931         uint16_t q_id;
 932
 933         /* Given slave mus not be in active list */
 934         RTE_ASSERT(find_slave_by_id(internals->active_slaves,
 935         internals->active_slave_count, slave_id) == internals->active_slave_count);
 936         RTE_SET_USED(internals); /* used only for assert when enabled */
 937
 938         memcpy(&port->actor, &initial, sizeof(struct port_params));
 939         /* Standard requires that port ID must be grater than 0.
 940          * Add 1 do get corresponding port_number */
 941         port->actor.port_number = rte_cpu_to_be_16(slave_id + 1);
 942
 943         memcpy(&port->partner, &initial, sizeof(struct port_params));
 944
 945         /* default states */
 946         port->actor_state = STATE_AGGREGATION | STATE_LACP_ACTIVE | STATE_DEFAULTED;
 947         port->partner_state = STATE_LACP_ACTIVE | STATE_AGGREGATION;
 948         port->sm_flags = SM_FLAGS_BEGIN;
 949
 950         /* use this port as agregator */
 951         port->aggregator_port_id = slave_id;
 952         rte_eth_promiscuous_enable(slave_id);
 953
 954         timer_cancel(&port->warning_timer);
 955
 956         if (port->mbuf_pool != NULL)
 957                 return;
 958
 959         RTE_ASSERT(port->rx_ring == NULL);
 960         RTE_ASSERT(port->tx_ring == NULL);
 961
 962         socket_id = rte_eth_dev_socket_id(slave_id);
 963         if (socket_id == (int)LCORE_ID_ANY)
 964                 socket_id = rte_socket_id();
 965
 966         element_size = sizeof(struct slow_protocol_frame) +
 967                                 RTE_PKTMBUF_HEADROOM;
 968
 969         /* The size of the mempool should be at least:
 970          * the sum of the TX descriptors + BOND_MODE_8023AX_SLAVE_TX_PKTS */
 971         total_tx_desc = BOND_MODE_8023AX_SLAVE_TX_PKTS;
 972         for (q_id = 0; q_id < bond_dev->data->nb_tx_queues; q_id++) {
 973                 bd_tx_q = (struct bond_tx_queue*)bond_dev->data->tx_queues[q_id];
 974                 total_tx_desc += bd_tx_q->nb_tx_desc;
 975         }
 976
 977         snprintf(mem_name, RTE_DIM(mem_name), "slave_port%u_pool", slave_id);
 978         port->mbuf_pool = rte_pktmbuf_pool_create(mem_name, total_tx_desc,
 979                 RTE_MEMPOOL_CACHE_MAX_SIZE >= 32 ?
 980                         32 : RTE_MEMPOOL_CACHE_MAX_SIZE,
 981                 0, element_size, socket_id);
 982
 983         /* Any memory allocation failure in initialization is critical because
 984          * resources can't be free, so reinitialization is impossible. */
 985         if (port->mbuf_pool == NULL) {
 986                 rte_panic("Slave %u: Failed to create memory pool '%s': %s\n",
 987                         slave_id, mem_name, rte_strerror(rte_errno));
 988         }
 989
 990         snprintf(mem_name, RTE_DIM(mem_name), "slave_%u_rx", slave_id);
 991         port->rx_ring = rte_ring_create(mem_name,
 992                         rte_align32pow2(BOND_MODE_8023AX_SLAVE_RX_PKTS), socket_id, 0);
 993
 994         if (port->rx_ring == NULL) {
 995                 rte_panic("Slave %u: Failed to create rx ring '%s': %s\n", slave_id,
 996                         mem_name, rte_strerror(rte_errno));
 997         }
 998
 999         /* TX ring is at least one pkt longer to make room for marker packet. */
1000         snprintf(mem_name, RTE_DIM(mem_name), "slave_%u_tx", slave_id);
1001         port->tx_ring = rte_ring_create(mem_name,
1002                         rte_align32pow2(BOND_MODE_8023AX_SLAVE_TX_PKTS + 1), socket_id, 0);
1003
1004         if (port->tx_ring == NULL) {
1005                 rte_panic("Slave %u: Failed to create tx ring '%s': %s\n", slave_id,
1006                         mem_name, rte_strerror(rte_errno));
1007         }
1008 }
1009
1010 int
1011 bond_mode_8023ad_deactivate_slave(struct rte_eth_dev *bond_dev __rte_unused,
1012                 uint16_t slave_id)
1013 {
1014         void *pkt = NULL;
1015         struct port *port = NULL;
1016         uint8_t old_partner_state;
1017
1018         port = &bond_mode_8023ad_ports[slave_id];
1019
1020         ACTOR_STATE_CLR(port, AGGREGATION);
1021         port->selected = UNSELECTED;
1022
1023         old_partner_state = port->partner_state;
1024         record_default(port);
1025
1026         /* If partner timeout state changes then disable timer */
1027         if (!((old_partner_state ^ port->partner_state) &
1028                         STATE_LACP_SHORT_TIMEOUT))
1029                 timer_cancel(&port->current_while_timer);
1030
1031         PARTNER_STATE_CLR(port, AGGREGATION);
1032         ACTOR_STATE_CLR(port, EXPIRED);
1033
1034         /* flush rx/tx rings */
1035         while (rte_ring_dequeue(port->rx_ring, &pkt) == 0)
1036                 rte_pktmbuf_free((struct rte_mbuf *)pkt);
1037
1038         while (rte_ring_dequeue(port->tx_ring, &pkt) == 0)
1039                         rte_pktmbuf_free((struct rte_mbuf *)pkt);
1040         return 0;
1041 }
1042
1043 void
1044 bond_mode_8023ad_mac_address_update(struct rte_eth_dev *bond_dev)
1045 {
1046         struct bond_dev_private *internals = bond_dev->data->dev_private;
1047         struct rte_ether_addr slave_addr;
1048         struct port *slave, *agg_slave;
1049         uint16_t slave_id, i, j;
1050
1051         bond_mode_8023ad_stop(bond_dev);
1052
1053         for (i = 0; i < internals->active_slave_count; i++) {
1054                 slave_id = internals->active_slaves[i];
1055                 slave = &bond_mode_8023ad_ports[slave_id];
1056                 rte_eth_macaddr_get(slave_id, &slave_addr);
1057
1058                 if (is_same_ether_addr(&slave_addr, &slave->actor.system))
1059                         continue;
1060
1061                 ether_addr_copy(&slave_addr, &slave->actor.system);
1062                 /* Do nothing if this port is not an aggregator. In other case
1063                  * Set NTT flag on every port that use this aggregator. */
1064                 if (slave->aggregator_port_id != slave_id)
1065                         continue;
1066
1067                 for (j = 0; j < internals->active_slave_count; j++) {
1068                         agg_slave = &bond_mode_8023ad_ports[internals->active_slaves[j]];
1069                         if (agg_slave->aggregator_port_id == slave_id)
1070                                 SM_FLAG_SET(agg_slave, NTT);
1071                 }
1072         }
1073
1074         if (bond_dev->data->dev_started)
1075                 bond_mode_8023ad_start(bond_dev);
1076 }
1077
1078 static void
1079 bond_mode_8023ad_conf_get(struct rte_eth_dev *dev,
1080                 struct rte_eth_bond_8023ad_conf *conf)
1081 {
1082         struct bond_dev_private *internals = dev->data->dev_private;
1083         struct mode8023ad_private *mode4 = &internals->mode4;
1084         uint64_t ms_ticks = rte_get_tsc_hz() / 1000;
1085
1086         conf->fast_periodic_ms = mode4->fast_periodic_timeout / ms_ticks;
1087         conf->slow_periodic_ms = mode4->slow_periodic_timeout / ms_ticks;
1088         conf->short_timeout_ms = mode4->short_timeout / ms_ticks;
1089         conf->long_timeout_ms = mode4->long_timeout / ms_ticks;
1090         conf->aggregate_wait_timeout_ms = mode4->aggregate_wait_timeout / ms_ticks;
1091         conf->tx_period_ms = mode4->tx_period_timeout / ms_ticks;
1092         conf->update_timeout_ms = mode4->update_timeout_us / 1000;
1093         conf->rx_marker_period_ms = mode4->rx_marker_timeout / ms_ticks;
1094         conf->slowrx_cb = mode4->slowrx_cb;
1095         conf->agg_selection = mode4->agg_selection;
1096 }
1097
1098 static void
1099 bond_mode_8023ad_conf_get_default(struct rte_eth_bond_8023ad_conf *conf)
1100 {
1101         conf->fast_periodic_ms = BOND_8023AD_FAST_PERIODIC_MS;
1102         conf->slow_periodic_ms = BOND_8023AD_SLOW_PERIODIC_MS;
1103         conf->short_timeout_ms = BOND_8023AD_SHORT_TIMEOUT_MS;
1104         conf->long_timeout_ms = BOND_8023AD_LONG_TIMEOUT_MS;
1105         conf->aggregate_wait_timeout_ms = BOND_8023AD_AGGREGATE_WAIT_TIMEOUT_MS;
1106         conf->tx_period_ms = BOND_8023AD_TX_MACHINE_PERIOD_MS;
1107         conf->rx_marker_period_ms = BOND_8023AD_RX_MARKER_PERIOD_MS;
1108         conf->update_timeout_ms = BOND_MODE_8023AX_UPDATE_TIMEOUT_MS;
1109         conf->slowrx_cb = NULL;
1110         conf->agg_selection = AGG_STABLE;
1111 }
1112
1113 static void
1114 bond_mode_8023ad_conf_assign(struct mode8023ad_private *mode4,
1115                 struct rte_eth_bond_8023ad_conf *conf)
1116 {
1117         uint64_t ms_ticks = rte_get_tsc_hz() / 1000;
1118
1119         mode4->fast_periodic_timeout = conf->fast_periodic_ms * ms_ticks;
1120         mode4->slow_periodic_timeout = conf->slow_periodic_ms * ms_ticks;
1121         mode4->short_timeout = conf->short_timeout_ms * ms_ticks;
1122         mode4->long_timeout = conf->long_timeout_ms * ms_ticks;
1123         mode4->aggregate_wait_timeout = conf->aggregate_wait_timeout_ms * ms_ticks;
1124         mode4->tx_period_timeout = conf->tx_period_ms * ms_ticks;
1125         mode4->rx_marker_timeout = conf->rx_marker_period_ms * ms_ticks;
1126         mode4->update_timeout_us = conf->update_timeout_ms * 1000;
1127
1128         mode4->dedicated_queues.enabled = 0;
1129         mode4->dedicated_queues.rx_qid = UINT16_MAX;
1130         mode4->dedicated_queues.tx_qid = UINT16_MAX;
1131 }
1132
1133 void
1134 bond_mode_8023ad_setup(struct rte_eth_dev *dev,
1135                 struct rte_eth_bond_8023ad_conf *conf)
1136 {
1137         struct rte_eth_bond_8023ad_conf def_conf;
1138         struct bond_dev_private *internals = dev->data->dev_private;
1139         struct mode8023ad_private *mode4 = &internals->mode4;
1140
1141         if (conf == NULL) {
1142                 conf = &def_conf;
1143                 bond_mode_8023ad_conf_get_default(conf);
1144         }
1145
1146         bond_mode_8023ad_stop(dev);
1147         bond_mode_8023ad_conf_assign(mode4, conf);
1148         mode4->slowrx_cb = conf->slowrx_cb;
1149         mode4->agg_selection = AGG_STABLE;
1150
1151         if (dev->data->dev_started)
1152                 bond_mode_8023ad_start(dev);
1153 }
1154
1155 int
1156 bond_mode_8023ad_enable(struct rte_eth_dev *bond_dev)
1157 {
1158         struct bond_dev_private *internals = bond_dev->data->dev_private;
1159         uint16_t i;
1160
1161         for (i = 0; i < internals->active_slave_count; i++)
1162                 bond_mode_8023ad_activate_slave(bond_dev,
1163                                 internals->active_slaves[i]);
1164
1165         return 0;
1166 }
1167
1168 int
1169 bond_mode_8023ad_start(struct rte_eth_dev *bond_dev)
1170 {
1171         struct bond_dev_private *internals = bond_dev->data->dev_private;
1172         struct mode8023ad_private *mode4 = &internals->mode4;
1173         static const uint64_t us = BOND_MODE_8023AX_UPDATE_TIMEOUT_MS * 1000;
1174
1175         rte_eth_macaddr_get(internals->port_id, &mode4->mac_addr);
1176         if (mode4->slowrx_cb)
1177                 return rte_eal_alarm_set(us, &bond_mode_8023ad_ext_periodic_cb,
1178                                          bond_dev);
1179
1180         return rte_eal_alarm_set(us, &bond_mode_8023ad_periodic_cb, bond_dev);
1181 }
1182
1183 void
1184 bond_mode_8023ad_stop(struct rte_eth_dev *bond_dev)
1185 {
1186         struct bond_dev_private *internals = bond_dev->data->dev_private;
1187         struct mode8023ad_private *mode4 = &internals->mode4;
1188
1189         if (mode4->slowrx_cb) {
1190                 rte_eal_alarm_cancel(&bond_mode_8023ad_ext_periodic_cb,
1191                                      bond_dev);
1192                 return;
1193         }
1194         rte_eal_alarm_cancel(&bond_mode_8023ad_periodic_cb, bond_dev);
1195 }
1196
1197 void
1198 bond_mode_8023ad_handle_slow_pkt(struct bond_dev_private *internals,
1199                                   uint16_t slave_id, struct rte_mbuf *pkt)
1200 {
1201         struct mode8023ad_private *mode4 = &internals->mode4;
1202         struct port *port = &bond_mode_8023ad_ports[slave_id];
1203         struct marker_header *m_hdr;
1204         uint64_t marker_timer, old_marker_timer;
1205         int retval;
1206         uint8_t wrn, subtype;
1207         /* If packet is a marker, we send response now by reusing given packet
1208          * and update only source MAC, destination MAC is multicast so don't
1209          * update it. Other frames will be handled later by state machines */
1210         subtype = rte_pktmbuf_mtod(pkt,
1211                         struct slow_protocol_frame *)->slow_protocol.subtype;
1212
1213         if (subtype == SLOW_SUBTYPE_MARKER) {
1214                 m_hdr = rte_pktmbuf_mtod(pkt, struct marker_header *);
1215
1216                 if (likely(m_hdr->marker.tlv_type_marker != MARKER_TLV_TYPE_INFO)) {
1217                         wrn = WRN_UNKNOWN_MARKER_TYPE;
1218                         goto free_out;
1219                 }
1220
1221                 /* Setup marker timer. Do it in loop in case concurrent access. */
1222                 do {
1223                         old_marker_timer = port->rx_marker_timer;
1224                         if (!timer_is_expired(&old_marker_timer)) {
1225                                 wrn = WRN_RX_MARKER_TO_FAST;
1226                                 goto free_out;
1227                         }
1228
1229                         timer_set(&marker_timer, mode4->rx_marker_timeout);
1230                         retval = rte_atomic64_cmpset(&port->rx_marker_timer,
1231                                 old_marker_timer, marker_timer);
1232                 } while (unlikely(retval == 0));
1233
1234                 m_hdr->marker.tlv_type_marker = MARKER_TLV_TYPE_RESP;
1235                 rte_eth_macaddr_get(slave_id, &m_hdr->eth_hdr.s_addr);
1236
1237                 if (internals->mode4.dedicated_queues.enabled == 0) {
1238                         int retval = rte_ring_enqueue(port->tx_ring, pkt);
1239                         if (retval != 0) {
1240                                 /* reset timer */
1241                                 port->rx_marker_timer = 0;
1242                                 wrn = WRN_TX_QUEUE_FULL;
1243                                 goto free_out;
1244                         }
1245                 } else {
1246                         /* Send packet directly to the slow queue */
1247                         uint16_t tx_count = rte_eth_tx_burst(slave_id,
1248                                         internals->mode4.dedicated_queues.tx_qid,
1249                                         &pkt, 1);
1250                         if (tx_count != 1) {
1251                                 /* reset timer */
1252                                 port->rx_marker_timer = 0;
1253                                 wrn = WRN_TX_QUEUE_FULL;
1254                                 goto free_out;
1255                         }
1256                 }
1257         } else if (likely(subtype == SLOW_SUBTYPE_LACP)) {
1258                 if (internals->mode4.dedicated_queues.enabled == 0) {
1259                         int retval = rte_ring_enqueue(port->rx_ring, pkt);
1260                         if (retval != 0) {
1261                                 /* If RX fing full free lacpdu message and drop packet */
1262                                 wrn = WRN_RX_QUEUE_FULL;
1263                                 goto free_out;
1264                         }
1265                 } else
1266                         rx_machine_update(internals, slave_id, pkt);
1267         } else {
1268                 wrn = WRN_UNKNOWN_SLOW_TYPE;
1269                 goto free_out;
1270         }
1271
1272         return;
1273
1274 free_out:
1275         set_warning_flags(port, wrn);
1276         rte_pktmbuf_free(pkt);
1277 }
1278
1279 int
1280 rte_eth_bond_8023ad_conf_get(uint16_t port_id,
1281                 struct rte_eth_bond_8023ad_conf *conf)
1282 {
1283         struct rte_eth_dev *bond_dev;
1284
1285         if (valid_bonded_port_id(port_id) != 0)
1286                 return -EINVAL;
1287
1288         if (conf == NULL)
1289                 return -EINVAL;
1290
1291         bond_dev = &rte_eth_devices[port_id];
1292         bond_mode_8023ad_conf_get(bond_dev, conf);
1293         return 0;
1294 }
1295
1296 int
1297 rte_eth_bond_8023ad_agg_selection_set(uint16_t port_id,
1298                 enum rte_bond_8023ad_agg_selection agg_selection)
1299 {
1300         struct rte_eth_dev *bond_dev;
1301         struct bond_dev_private *internals;
1302         struct mode8023ad_private *mode4;
1303
1304         bond_dev = &rte_eth_devices[port_id];
1305         internals = bond_dev->data->dev_private;
1306
1307         if (valid_bonded_port_id(port_id) != 0)
1308                 return -EINVAL;
1309         if (internals->mode != 4)
1310                 return -EINVAL;
1311
1312         mode4 = &internals->mode4;
1313         if (agg_selection == AGG_COUNT || agg_selection == AGG_BANDWIDTH
1314                         || agg_selection == AGG_STABLE)
1315                 mode4->agg_selection = agg_selection;
1316         return 0;
1317 }
1318
1319 int rte_eth_bond_8023ad_agg_selection_get(uint16_t port_id)
1320 {
1321         struct rte_eth_dev *bond_dev;
1322         struct bond_dev_private *internals;
1323         struct mode8023ad_private *mode4;
1324
1325         bond_dev = &rte_eth_devices[port_id];
1326         internals = bond_dev->data->dev_private;
1327
1328         if (valid_bonded_port_id(port_id) != 0)
1329                 return -EINVAL;
1330         if (internals->mode != 4)
1331                 return -EINVAL;
1332         mode4 = &internals->mode4;
1333
1334         return mode4->agg_selection;
1335 }
1336
1337
1338
1339 static int
1340 bond_8023ad_setup_validate(uint16_t port_id,
1341                 struct rte_eth_bond_8023ad_conf *conf)
1342 {
1343         if (valid_bonded_port_id(port_id) != 0)
1344                 return -EINVAL;
1345
1346         if (conf != NULL) {
1347                 /* Basic sanity check */
1348                 if (conf->slow_periodic_ms == 0 ||
1349                                 conf->fast_periodic_ms >= conf->slow_periodic_ms ||
1350                                 conf->long_timeout_ms == 0 ||
1351                                 conf->short_timeout_ms >= conf->long_timeout_ms ||
1352                                 conf->aggregate_wait_timeout_ms == 0 ||
1353                                 conf->tx_period_ms == 0 ||
1354                                 conf->rx_marker_period_ms == 0 ||
1355                                 conf->update_timeout_ms == 0) {
1356                         RTE_BOND_LOG(ERR, "given mode 4 configuration is invalid");
1357                         return -EINVAL;
1358                 }
1359         }
1360
1361         return 0;
1362 }
1363
1364
1365 int
1366 rte_eth_bond_8023ad_setup(uint16_t port_id,
1367                 struct rte_eth_bond_8023ad_conf *conf)
1368 {
1369         struct rte_eth_dev *bond_dev;
1370         int err;
1371
1372         err = bond_8023ad_setup_validate(port_id, conf);
1373         if (err != 0)
1374                 return err;
1375
1376         bond_dev = &rte_eth_devices[port_id];
1377         bond_mode_8023ad_setup(bond_dev, conf);
1378
1379         return 0;
1380 }
1381
1382
1383
1384
1385
1386 int
1387 rte_eth_bond_8023ad_slave_info(uint16_t port_id, uint16_t slave_id,
1388                 struct rte_eth_bond_8023ad_slave_info *info)
1389 {
1390         struct rte_eth_dev *bond_dev;
1391         struct bond_dev_private *internals;
1392         struct port *port;
1393
1394         if (info == NULL || valid_bonded_port_id(port_id) != 0 ||
1395                         rte_eth_bond_mode_get(port_id) != BONDING_MODE_8023AD)
1396                 return -EINVAL;
1397
1398         bond_dev = &rte_eth_devices[port_id];
1399
1400         internals = bond_dev->data->dev_private;
1401         if (find_slave_by_id(internals->active_slaves,
1402                         internals->active_slave_count, slave_id) ==
1403                                 internals->active_slave_count)
1404                 return -EINVAL;
1405
1406         port = &bond_mode_8023ad_ports[slave_id];
1407         info->selected = port->selected;
1408
1409         info->actor_state = port->actor_state;
1410         rte_memcpy(&info->actor, &port->actor, sizeof(port->actor));
1411
1412         info->partner_state = port->partner_state;
1413         rte_memcpy(&info->partner, &port->partner, sizeof(port->partner));
1414
1415         info->agg_port_id = port->aggregator_port_id;
1416         return 0;
1417 }
1418
1419 static int
1420 bond_8023ad_ext_validate(uint16_t port_id, uint16_t slave_id)
1421 {
1422         struct rte_eth_dev *bond_dev;
1423         struct bond_dev_private *internals;
1424         struct mode8023ad_private *mode4;
1425
1426         if (rte_eth_bond_mode_get(port_id) != BONDING_MODE_8023AD)
1427                 return -EINVAL;
1428
1429         bond_dev = &rte_eth_devices[port_id];
1430
1431         if (!bond_dev->data->dev_started)
1432                 return -EINVAL;
1433
1434         internals = bond_dev->data->dev_private;
1435         if (find_slave_by_id(internals->active_slaves,
1436                         internals->active_slave_count, slave_id) ==
1437                                 internals->active_slave_count)
1438                 return -EINVAL;
1439
1440         mode4 = &internals->mode4;
1441         if (mode4->slowrx_cb == NULL)
1442                 return -EINVAL;
1443
1444         return 0;
1445 }
1446
1447 int
1448 rte_eth_bond_8023ad_ext_collect(uint16_t port_id, uint16_t slave_id,
1449                                 int enabled)
1450 {
1451         struct port *port;
1452         int res;
1453
1454         res = bond_8023ad_ext_validate(port_id, slave_id);
1455         if (res != 0)
1456                 return res;
1457
1458         port = &bond_mode_8023ad_ports[slave_id];
1459
1460         if (enabled)
1461                 ACTOR_STATE_SET(port, COLLECTING);
1462         else
1463                 ACTOR_STATE_CLR(port, COLLECTING);
1464
1465         return 0;
1466 }
1467
1468 int
1469 rte_eth_bond_8023ad_ext_distrib(uint16_t port_id, uint16_t slave_id,
1470                                 int enabled)
1471 {
1472         struct port *port;
1473         int res;
1474
1475         res = bond_8023ad_ext_validate(port_id, slave_id);
1476         if (res != 0)
1477                 return res;
1478
1479         port = &bond_mode_8023ad_ports[slave_id];
1480
1481         if (enabled)
1482                 ACTOR_STATE_SET(port, DISTRIBUTING);
1483         else
1484                 ACTOR_STATE_CLR(port, DISTRIBUTING);
1485
1486         return 0;
1487 }
1488
1489 int
1490 rte_eth_bond_8023ad_ext_distrib_get(uint16_t port_id, uint16_t slave_id)
1491 {
1492         struct port *port;
1493         int err;
1494
1495         err = bond_8023ad_ext_validate(port_id, slave_id);
1496         if (err != 0)
1497                 return err;
1498
1499         port = &bond_mode_8023ad_ports[slave_id];
1500         return ACTOR_STATE(port, DISTRIBUTING);
1501 }
1502
1503 int
1504 rte_eth_bond_8023ad_ext_collect_get(uint16_t port_id, uint16_t slave_id)
1505 {
1506         struct port *port;
1507         int err;
1508
1509         err = bond_8023ad_ext_validate(port_id, slave_id);
1510         if (err != 0)
1511                 return err;
1512
1513         port = &bond_mode_8023ad_ports[slave_id];
1514         return ACTOR_STATE(port, COLLECTING);
1515 }
1516
1517 int
1518 rte_eth_bond_8023ad_ext_slowtx(uint16_t port_id, uint16_t slave_id,
1519                 struct rte_mbuf *lacp_pkt)
1520 {
1521         struct port *port;
1522         int res;
1523
1524         res = bond_8023ad_ext_validate(port_id, slave_id);
1525         if (res != 0)
1526                 return res;
1527
1528         port = &bond_mode_8023ad_ports[slave_id];
1529
1530         if (rte_pktmbuf_pkt_len(lacp_pkt) < sizeof(struct lacpdu_header))
1531                 return -EINVAL;
1532
1533         struct lacpdu_header *lacp;
1534
1535         /* only enqueue LACPDUs */
1536         lacp = rte_pktmbuf_mtod(lacp_pkt, struct lacpdu_header *);
1537         if (lacp->lacpdu.subtype != SLOW_SUBTYPE_LACP)
1538                 return -EINVAL;
1539
1540         MODE4_DEBUG("sending LACP frame\n");
1541
1542         return rte_ring_enqueue(port->tx_ring, lacp_pkt);
1543 }
1544
1545 static void
1546 bond_mode_8023ad_ext_periodic_cb(void *arg)
1547 {
1548         struct rte_eth_dev *bond_dev = arg;
1549         struct bond_dev_private *internals = bond_dev->data->dev_private;
1550         struct mode8023ad_private *mode4 = &internals->mode4;
1551         struct port *port;
1552         void *pkt = NULL;
1553         uint16_t i, slave_id;
1554
1555         for (i = 0; i < internals->active_slave_count; i++) {
1556                 slave_id = internals->active_slaves[i];
1557                 port = &bond_mode_8023ad_ports[slave_id];
1558
1559                 if (rte_ring_dequeue(port->rx_ring, &pkt) == 0) {
1560                         struct rte_mbuf *lacp_pkt = pkt;
1561                         struct lacpdu_header *lacp;
1562
1563                         lacp = rte_pktmbuf_mtod(lacp_pkt,
1564                                                 struct lacpdu_header *);
1565                         RTE_VERIFY(lacp->lacpdu.subtype == SLOW_SUBTYPE_LACP);
1566
1567                         /* This is LACP frame so pass it to rx callback.
1568                          * Callback is responsible for freeing mbuf.
1569                          */
1570                         mode4->slowrx_cb(slave_id, lacp_pkt);
1571                 }
1572         }
1573
1574         rte_eal_alarm_set(internals->mode4.update_timeout_us,
1575                         bond_mode_8023ad_ext_periodic_cb, arg);
1576 }
1577
1578 int
1579 rte_eth_bond_8023ad_dedicated_queues_enable(uint16_t port)
1580 {
1581         int retval = 0;
1582         struct rte_eth_dev *dev = &rte_eth_devices[port];
1583         struct bond_dev_private *internals = (struct bond_dev_private *)
1584                 dev->data->dev_private;
1585
1586         if (check_for_bonded_ethdev(dev) != 0)
1587                 return -1;
1588
1589         if (bond_8023ad_slow_pkt_hw_filter_supported(port) != 0)
1590                 return -1;
1591
1592         /* Device must be stopped to set up slow queue */
1593         if (dev->data->dev_started)
1594                 return -1;
1595
1596         internals->mode4.dedicated_queues.enabled = 1;
1597
1598         bond_ethdev_mode_set(dev, internals->mode);
1599         return retval;
1600 }
1601
1602 int
1603 rte_eth_bond_8023ad_dedicated_queues_disable(uint16_t port)
1604 {
1605         int retval = 0;
1606         struct rte_eth_dev *dev = &rte_eth_devices[port];
1607         struct bond_dev_private *internals = (struct bond_dev_private *)
1608                 dev->data->dev_private;
1609
1610         if (check_for_bonded_ethdev(dev) != 0)
1611                 return -1;
1612
1613         /* Device must be stopped to set up slow queue */
1614         if (dev->data->dev_started)
1615                 return -1;
1616
1617         internals->mode4.dedicated_queues.enabled = 0;
1618
1619         bond_ethdev_mode_set(dev, internals->mode);
1620
1621         return retval;
1622 }