drivers/net/mlx5/mlx5_rxq.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright 2015 6WIND S.A.
   5  *   Copyright 2015 Mellanox.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of 6WIND S.A. nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <stddef.h>
  35 #include <assert.h>
  36 #include <errno.h>
  37 #include <string.h>
  38 #include <stdint.h>
  39
  40 /* Verbs header. */
  41 /* ISO C doesn't support unnamed structs/unions, disabling -pedantic. */
  42 #ifdef PEDANTIC
  43 #pragma GCC diagnostic ignored "-pedantic"
  44 #endif
  45 #include <infiniband/verbs.h>
  46 #ifdef PEDANTIC
  47 #pragma GCC diagnostic error "-pedantic"
  48 #endif
  49
  50 /* DPDK headers don't like -pedantic. */
  51 #ifdef PEDANTIC
  52 #pragma GCC diagnostic ignored "-pedantic"
  53 #endif
  54 #include <rte_mbuf.h>
  55 #include <rte_malloc.h>
  56 #include <rte_ethdev.h>
  57 #include <rte_common.h>
  58 #ifdef PEDANTIC
  59 #pragma GCC diagnostic error "-pedantic"
  60 #endif
  61
  62 #include "mlx5.h"
  63 #include "mlx5_rxtx.h"
  64 #include "mlx5_utils.h"
  65 #include "mlx5_autoconf.h"
  66 #include "mlx5_defs.h"
  67
  68 /* Initialization data for hash RX queues. */
  69 const struct hash_rxq_init hash_rxq_init[] = {
  70         [HASH_RXQ_TCPV4] = {
  71                 .hash_fields = (IBV_EXP_RX_HASH_SRC_IPV4 |
  72                                 IBV_EXP_RX_HASH_DST_IPV4 |
  73                                 IBV_EXP_RX_HASH_SRC_PORT_TCP |
  74                                 IBV_EXP_RX_HASH_DST_PORT_TCP),
  75                 .dpdk_rss_hf = ETH_RSS_NONFRAG_IPV4_TCP,
  76                 .flow_priority = 0,
  77                 .flow_spec.tcp_udp = {
  78                         .type = IBV_EXP_FLOW_SPEC_TCP,
  79                         .size = sizeof(hash_rxq_init[0].flow_spec.tcp_udp),
  80                 },
  81                 .underlayer = &hash_rxq_init[HASH_RXQ_IPV4],
  82         },
  83         [HASH_RXQ_UDPV4] = {
  84                 .hash_fields = (IBV_EXP_RX_HASH_SRC_IPV4 |
  85                                 IBV_EXP_RX_HASH_DST_IPV4 |
  86                                 IBV_EXP_RX_HASH_SRC_PORT_UDP |
  87                                 IBV_EXP_RX_HASH_DST_PORT_UDP),
  88                 .dpdk_rss_hf = ETH_RSS_NONFRAG_IPV4_UDP,
  89                 .flow_priority = 0,
  90                 .flow_spec.tcp_udp = {
  91                         .type = IBV_EXP_FLOW_SPEC_UDP,
  92                         .size = sizeof(hash_rxq_init[0].flow_spec.tcp_udp),
  93                 },
  94                 .underlayer = &hash_rxq_init[HASH_RXQ_IPV4],
  95         },
  96         [HASH_RXQ_IPV4] = {
  97                 .hash_fields = (IBV_EXP_RX_HASH_SRC_IPV4 |
  98                                 IBV_EXP_RX_HASH_DST_IPV4),
  99                 .dpdk_rss_hf = (ETH_RSS_IPV4 |
 100                                 ETH_RSS_FRAG_IPV4),
 101                 .flow_priority = 1,
 102                 .flow_spec.ipv4 = {
 103                         .type = IBV_EXP_FLOW_SPEC_IPV4,
 104                         .size = sizeof(hash_rxq_init[0].flow_spec.ipv4),
 105                 },
 106                 .underlayer = &hash_rxq_init[HASH_RXQ_ETH],
 107         },
 108 #ifdef HAVE_FLOW_SPEC_IPV6
 109         [HASH_RXQ_TCPV6] = {
 110                 .hash_fields = (IBV_EXP_RX_HASH_SRC_IPV6 |
 111                                 IBV_EXP_RX_HASH_DST_IPV6 |
 112                                 IBV_EXP_RX_HASH_SRC_PORT_TCP |
 113                                 IBV_EXP_RX_HASH_DST_PORT_TCP),
 114                 .dpdk_rss_hf = ETH_RSS_NONFRAG_IPV6_TCP,
 115                 .flow_priority = 0,
 116                 .flow_spec.tcp_udp = {
 117                         .type = IBV_EXP_FLOW_SPEC_TCP,
 118                         .size = sizeof(hash_rxq_init[0].flow_spec.tcp_udp),
 119                 },
 120                 .underlayer = &hash_rxq_init[HASH_RXQ_IPV6],
 121         },
 122         [HASH_RXQ_UDPV6] = {
 123                 .hash_fields = (IBV_EXP_RX_HASH_SRC_IPV6 |
 124                                 IBV_EXP_RX_HASH_DST_IPV6 |
 125                                 IBV_EXP_RX_HASH_SRC_PORT_UDP |
 126                                 IBV_EXP_RX_HASH_DST_PORT_UDP),
 127                 .dpdk_rss_hf = ETH_RSS_NONFRAG_IPV6_UDP,
 128                 .flow_priority = 0,
 129                 .flow_spec.tcp_udp = {
 130                         .type = IBV_EXP_FLOW_SPEC_UDP,
 131                         .size = sizeof(hash_rxq_init[0].flow_spec.tcp_udp),
 132                 },
 133                 .underlayer = &hash_rxq_init[HASH_RXQ_IPV6],
 134         },
 135         [HASH_RXQ_IPV6] = {
 136                 .hash_fields = (IBV_EXP_RX_HASH_SRC_IPV6 |
 137                                 IBV_EXP_RX_HASH_DST_IPV6),
 138                 .dpdk_rss_hf = (ETH_RSS_IPV6 |
 139                                 ETH_RSS_FRAG_IPV6),
 140                 .flow_priority = 1,
 141                 .flow_spec.ipv6 = {
 142                         .type = IBV_EXP_FLOW_SPEC_IPV6,
 143                         .size = sizeof(hash_rxq_init[0].flow_spec.ipv6),
 144                 },
 145                 .underlayer = &hash_rxq_init[HASH_RXQ_ETH],
 146         },
 147 #endif /* HAVE_FLOW_SPEC_IPV6 */
 148         [HASH_RXQ_ETH] = {
 149                 .hash_fields = 0,
 150                 .dpdk_rss_hf = 0,
 151                 .flow_priority = 2,
 152                 .flow_spec.eth = {
 153                         .type = IBV_EXP_FLOW_SPEC_ETH,
 154                         .size = sizeof(hash_rxq_init[0].flow_spec.eth),
 155                 },
 156                 .underlayer = NULL,
 157         },
 158 };
 159
 160 /* Number of entries in hash_rxq_init[]. */
 161 const unsigned int hash_rxq_init_n = RTE_DIM(hash_rxq_init);
 162
 163 /* Initialization data for hash RX queue indirection tables. */
 164 static const struct ind_table_init ind_table_init[] = {
 165         {
 166                 .max_size = -1u, /* Superseded by HW limitations. */
 167                 .hash_types =
 168                         1 << HASH_RXQ_TCPV4 |
 169                         1 << HASH_RXQ_UDPV4 |
 170                         1 << HASH_RXQ_IPV4 |
 171 #ifdef HAVE_FLOW_SPEC_IPV6
 172                         1 << HASH_RXQ_TCPV6 |
 173                         1 << HASH_RXQ_UDPV6 |
 174                         1 << HASH_RXQ_IPV6 |
 175 #endif /* HAVE_FLOW_SPEC_IPV6 */
 176                         0,
 177 #ifdef HAVE_FLOW_SPEC_IPV6
 178                 .hash_types_n = 6,
 179 #else /* HAVE_FLOW_SPEC_IPV6 */
 180                 .hash_types_n = 3,
 181 #endif /* HAVE_FLOW_SPEC_IPV6 */
 182         },
 183         {
 184                 .max_size = 1,
 185                 .hash_types = 1 << HASH_RXQ_ETH,
 186                 .hash_types_n = 1,
 187         },
 188 };
 189
 190 #define IND_TABLE_INIT_N RTE_DIM(ind_table_init)
 191
 192 /* Default RSS hash key also used for ConnectX-3. */
 193 uint8_t rss_hash_default_key[] = {
 194         0x2c, 0xc6, 0x81, 0xd1,
 195         0x5b, 0xdb, 0xf4, 0xf7,
 196         0xfc, 0xa2, 0x83, 0x19,
 197         0xdb, 0x1a, 0x3e, 0x94,
 198         0x6b, 0x9e, 0x38, 0xd9,
 199         0x2c, 0x9c, 0x03, 0xd1,
 200         0xad, 0x99, 0x44, 0xa7,
 201         0xd9, 0x56, 0x3d, 0x59,
 202         0x06, 0x3c, 0x25, 0xf3,
 203         0xfc, 0x1f, 0xdc, 0x2a,
 204 };
 205
 206 /* Length of the default RSS hash key. */
 207 const size_t rss_hash_default_key_len = sizeof(rss_hash_default_key);
 208
 209 /**
 210  * Populate flow steering rule for a given hash RX queue type using
 211  * information from hash_rxq_init[]. Nothing is written to flow_attr when
 212  * flow_attr_size is not large enough, but the required size is still returned.
 213  *
 214  * @param priv
 215  *   Pointer to private structure.
 216  * @param[out] flow_attr
 217  *   Pointer to flow attribute structure to fill. Note that the allocated
 218  *   area must be larger and large enough to hold all flow specifications.
 219  * @param flow_attr_size
 220  *   Entire size of flow_attr and trailing room for flow specifications.
 221  * @param type
 222  *   Hash RX queue type to use for flow steering rule.
 223  *
 224  * @return
 225  *   Total size of the flow attribute buffer. No errors are defined.
 226  */
 227 size_t
 228 priv_flow_attr(struct priv *priv, struct ibv_exp_flow_attr *flow_attr,
 229                size_t flow_attr_size, enum hash_rxq_type type)
 230 {
 231         size_t offset = sizeof(*flow_attr);
 232         const struct hash_rxq_init *init = &hash_rxq_init[type];
 233
 234         assert(priv != NULL);
 235         assert((size_t)type < RTE_DIM(hash_rxq_init));
 236         do {
 237                 offset += init->flow_spec.hdr.size;
 238                 init = init->underlayer;
 239         } while (init != NULL);
 240         if (offset > flow_attr_size)
 241                 return offset;
 242         flow_attr_size = offset;
 243         init = &hash_rxq_init[type];
 244         *flow_attr = (struct ibv_exp_flow_attr){
 245                 .type = IBV_EXP_FLOW_ATTR_NORMAL,
 246 #ifdef MLX5_FDIR_SUPPORT
 247                 /* Priorities < 3 are reserved for flow director. */
 248                 .priority = init->flow_priority + 3,
 249 #else /* MLX5_FDIR_SUPPORT */
 250                 .priority = init->flow_priority,
 251 #endif /* MLX5_FDIR_SUPPORT */
 252                 .num_of_specs = 0,
 253                 .port = priv->port,
 254                 .flags = 0,
 255         };
 256         do {
 257                 offset -= init->flow_spec.hdr.size;
 258                 memcpy((void *)((uintptr_t)flow_attr + offset),
 259                        &init->flow_spec,
 260                        init->flow_spec.hdr.size);
 261                 ++flow_attr->num_of_specs;
 262                 init = init->underlayer;
 263         } while (init != NULL);
 264         return flow_attr_size;
 265 }
 266
 267 /**
 268  * Convert hash type position in indirection table initializer to
 269  * hash RX queue type.
 270  *
 271  * @param table
 272  *   Indirection table initializer.
 273  * @param pos
 274  *   Hash type position.
 275  *
 276  * @return
 277  *   Hash RX queue type.
 278  */
 279 static enum hash_rxq_type
 280 hash_rxq_type_from_pos(const struct ind_table_init *table, unsigned int pos)
 281 {
 282         enum hash_rxq_type type = 0;
 283
 284         assert(pos < table->hash_types_n);
 285         do {
 286                 if ((table->hash_types & (1 << type)) && (pos-- == 0))
 287                         break;
 288                 ++type;
 289         } while (1);
 290         return type;
 291 }
 292
 293 /**
 294  * Filter out disabled hash RX queue types from ind_table_init[].
 295  *
 296  * @param priv
 297  *   Pointer to private structure.
 298  * @param[out] table
 299  *   Output table.
 300  *
 301  * @return
 302  *   Number of table entries.
 303  */
 304 static unsigned int
 305 priv_make_ind_table_init(struct priv *priv,
 306                          struct ind_table_init (*table)[IND_TABLE_INIT_N])
 307 {
 308         uint64_t rss_hf;
 309         unsigned int i;
 310         unsigned int j;
 311         unsigned int table_n = 0;
 312         /* Mandatory to receive frames not handled by normal hash RX queues. */
 313         unsigned int hash_types_sup = 1 << HASH_RXQ_ETH;
 314
 315         rss_hf = priv->rss_hf;
 316         /* Process other protocols only if more than one queue. */
 317         if (priv->rxqs_n > 1)
 318                 for (i = 0; (i != hash_rxq_init_n); ++i)
 319                         if (rss_hf & hash_rxq_init[i].dpdk_rss_hf)
 320                                 hash_types_sup |= (1 << i);
 321
 322         /* Filter out entries whose protocols are not in the set. */
 323         for (i = 0, j = 0; (i != IND_TABLE_INIT_N); ++i) {
 324                 unsigned int nb;
 325                 unsigned int h;
 326
 327                 /* j is increased only if the table has valid protocols. */
 328                 assert(j <= i);
 329                 (*table)[j] = ind_table_init[i];
 330                 (*table)[j].hash_types &= hash_types_sup;
 331                 for (h = 0, nb = 0; (h != hash_rxq_init_n); ++h)
 332                         if (((*table)[j].hash_types >> h) & 0x1)
 333                                 ++nb;
 334                 (*table)[i].hash_types_n = nb;
 335                 if (nb) {
 336                         ++table_n;
 337                         ++j;
 338                 }
 339         }
 340         return table_n;
 341 }
 342
 343 /**
 344  * Initialize hash RX queues and indirection table.
 345  *
 346  * @param priv
 347  *   Pointer to private structure.
 348  *
 349  * @return
 350  *   0 on success, errno value on failure.
 351  */
 352 int
 353 priv_create_hash_rxqs(struct priv *priv)
 354 {
 355         struct ibv_exp_wq *wqs[priv->reta_idx_n];
 356         struct ind_table_init ind_table_init[IND_TABLE_INIT_N];
 357         unsigned int ind_tables_n =
 358                 priv_make_ind_table_init(priv, &ind_table_init);
 359         unsigned int hash_rxqs_n = 0;
 360         struct hash_rxq (*hash_rxqs)[] = NULL;
 361         struct ibv_exp_rwq_ind_table *(*ind_tables)[] = NULL;
 362         unsigned int i;
 363         unsigned int j;
 364         unsigned int k;
 365         int err = 0;
 366
 367         assert(priv->ind_tables == NULL);
 368         assert(priv->ind_tables_n == 0);
 369         assert(priv->hash_rxqs == NULL);
 370         assert(priv->hash_rxqs_n == 0);
 371         assert(priv->pd != NULL);
 372         assert(priv->ctx != NULL);
 373         if (priv->rxqs_n == 0)
 374                 return EINVAL;
 375         assert(priv->rxqs != NULL);
 376         if (ind_tables_n == 0) {
 377                 ERROR("all hash RX queue types have been filtered out,"
 378                       " indirection table cannot be created");
 379                 return EINVAL;
 380         }
 381         if (priv->rxqs_n & (priv->rxqs_n - 1)) {
 382                 INFO("%u RX queues are configured, consider rounding this"
 383                      " number to the next power of two for better balancing",
 384                      priv->rxqs_n);
 385                 DEBUG("indirection table extended to assume %u WQs",
 386                       priv->reta_idx_n);
 387         }
 388         for (i = 0; (i != priv->reta_idx_n); ++i)
 389                 wqs[i] = (*priv->rxqs)[(*priv->reta_idx)[i]]->wq;
 390         /* Get number of hash RX queues to configure. */
 391         for (i = 0, hash_rxqs_n = 0; (i != ind_tables_n); ++i)
 392                 hash_rxqs_n += ind_table_init[i].hash_types_n;
 393         DEBUG("allocating %u hash RX queues for %u WQs, %u indirection tables",
 394               hash_rxqs_n, priv->rxqs_n, ind_tables_n);
 395         /* Create indirection tables. */
 396         ind_tables = rte_calloc(__func__, ind_tables_n,
 397                                 sizeof((*ind_tables)[0]), 0);
 398         if (ind_tables == NULL) {
 399                 err = ENOMEM;
 400                 ERROR("cannot allocate indirection tables container: %s",
 401                       strerror(err));
 402                 goto error;
 403         }
 404         for (i = 0; (i != ind_tables_n); ++i) {
 405                 struct ibv_exp_rwq_ind_table_init_attr ind_init_attr = {
 406                         .pd = priv->pd,
 407                         .log_ind_tbl_size = 0, /* Set below. */
 408                         .ind_tbl = wqs,
 409                         .comp_mask = 0,
 410                 };
 411                 unsigned int ind_tbl_size = ind_table_init[i].max_size;
 412                 struct ibv_exp_rwq_ind_table *ind_table;
 413
 414                 if (priv->reta_idx_n < ind_tbl_size)
 415                         ind_tbl_size = priv->reta_idx_n;
 416                 ind_init_attr.log_ind_tbl_size = log2above(ind_tbl_size);
 417                 errno = 0;
 418                 ind_table = ibv_exp_create_rwq_ind_table(priv->ctx,
 419                                                          &ind_init_attr);
 420                 if (ind_table != NULL) {
 421                         (*ind_tables)[i] = ind_table;
 422                         continue;
 423                 }
 424                 /* Not clear whether errno is set. */
 425                 err = (errno ? errno : EINVAL);
 426                 ERROR("RX indirection table creation failed with error %d: %s",
 427                       err, strerror(err));
 428                 goto error;
 429         }
 430         /* Allocate array that holds hash RX queues and related data. */
 431         hash_rxqs = rte_calloc(__func__, hash_rxqs_n,
 432                                sizeof((*hash_rxqs)[0]), 0);
 433         if (hash_rxqs == NULL) {
 434                 err = ENOMEM;
 435                 ERROR("cannot allocate hash RX queues container: %s",
 436                       strerror(err));
 437                 goto error;
 438         }
 439         for (i = 0, j = 0, k = 0;
 440              ((i != hash_rxqs_n) && (j != ind_tables_n));
 441              ++i) {
 442                 struct hash_rxq *hash_rxq = &(*hash_rxqs)[i];
 443                 enum hash_rxq_type type =
 444                         hash_rxq_type_from_pos(&ind_table_init[j], k);
 445                 struct rte_eth_rss_conf *priv_rss_conf =
 446                         (*priv->rss_conf)[type];
 447                 struct ibv_exp_rx_hash_conf hash_conf = {
 448                         .rx_hash_function = IBV_EXP_RX_HASH_FUNC_TOEPLITZ,
 449                         .rx_hash_key_len = (priv_rss_conf ?
 450                                             priv_rss_conf->rss_key_len :
 451                                             rss_hash_default_key_len),
 452                         .rx_hash_key = (priv_rss_conf ?
 453                                         priv_rss_conf->rss_key :
 454                                         rss_hash_default_key),
 455                         .rx_hash_fields_mask = hash_rxq_init[type].hash_fields,
 456                         .rwq_ind_tbl = (*ind_tables)[j],
 457                 };
 458                 struct ibv_exp_qp_init_attr qp_init_attr = {
 459                         .max_inl_recv = 0, /* Currently not supported. */
 460                         .qp_type = IBV_QPT_RAW_PACKET,
 461                         .comp_mask = (IBV_EXP_QP_INIT_ATTR_PD |
 462                                       IBV_EXP_QP_INIT_ATTR_RX_HASH),
 463                         .pd = priv->pd,
 464                         .rx_hash_conf = &hash_conf,
 465                         .port_num = priv->port,
 466                 };
 467
 468                 DEBUG("using indirection table %u for hash RX queue %u type %d",
 469                       j, i, type);
 470                 *hash_rxq = (struct hash_rxq){
 471                         .priv = priv,
 472                         .qp = ibv_exp_create_qp(priv->ctx, &qp_init_attr),
 473                         .type = type,
 474                 };
 475                 if (hash_rxq->qp == NULL) {
 476                         err = (errno ? errno : EINVAL);
 477                         ERROR("Hash RX QP creation failure: %s",
 478                               strerror(err));
 479                         goto error;
 480                 }
 481                 if (++k < ind_table_init[j].hash_types_n)
 482                         continue;
 483                 /* Switch to the next indirection table and reset hash RX
 484                  * queue type array index. */
 485                 ++j;
 486                 k = 0;
 487         }
 488         priv->ind_tables = ind_tables;
 489         priv->ind_tables_n = ind_tables_n;
 490         priv->hash_rxqs = hash_rxqs;
 491         priv->hash_rxqs_n = hash_rxqs_n;
 492         assert(err == 0);
 493         return 0;
 494 error:
 495         if (hash_rxqs != NULL) {
 496                 for (i = 0; (i != hash_rxqs_n); ++i) {
 497                         struct ibv_qp *qp = (*hash_rxqs)[i].qp;
 498
 499                         if (qp == NULL)
 500                                 continue;
 501                         claim_zero(ibv_destroy_qp(qp));
 502                 }
 503                 rte_free(hash_rxqs);
 504         }
 505         if (ind_tables != NULL) {
 506                 for (j = 0; (j != ind_tables_n); ++j) {
 507                         struct ibv_exp_rwq_ind_table *ind_table =
 508                                 (*ind_tables)[j];
 509
 510                         if (ind_table == NULL)
 511                                 continue;
 512                         claim_zero(ibv_exp_destroy_rwq_ind_table(ind_table));
 513                 }
 514                 rte_free(ind_tables);
 515         }
 516         return err;
 517 }
 518
 519 /**
 520  * Clean up hash RX queues and indirection table.
 521  *
 522  * @param priv
 523  *   Pointer to private structure.
 524  */
 525 void
 526 priv_destroy_hash_rxqs(struct priv *priv)
 527 {
 528         unsigned int i;
 529
 530         DEBUG("destroying %u hash RX queues", priv->hash_rxqs_n);
 531         if (priv->hash_rxqs_n == 0) {
 532                 assert(priv->hash_rxqs == NULL);
 533                 assert(priv->ind_tables == NULL);
 534                 return;
 535         }
 536         for (i = 0; (i != priv->hash_rxqs_n); ++i) {
 537                 struct hash_rxq *hash_rxq = &(*priv->hash_rxqs)[i];
 538                 unsigned int j, k;
 539
 540                 assert(hash_rxq->priv == priv);
 541                 assert(hash_rxq->qp != NULL);
 542                 /* Also check that there are no remaining flows. */
 543                 for (j = 0; (j != RTE_DIM(hash_rxq->special_flow)); ++j)
 544                         for (k = 0;
 545                              (k != RTE_DIM(hash_rxq->special_flow[j]));
 546                              ++k)
 547                                 assert(hash_rxq->special_flow[j][k] == NULL);
 548                 for (j = 0; (j != RTE_DIM(hash_rxq->mac_flow)); ++j)
 549                         for (k = 0; (k != RTE_DIM(hash_rxq->mac_flow[j])); ++k)
 550                                 assert(hash_rxq->mac_flow[j][k] == NULL);
 551                 claim_zero(ibv_destroy_qp(hash_rxq->qp));
 552         }
 553         priv->hash_rxqs_n = 0;
 554         rte_free(priv->hash_rxqs);
 555         priv->hash_rxqs = NULL;
 556         for (i = 0; (i != priv->ind_tables_n); ++i) {
 557                 struct ibv_exp_rwq_ind_table *ind_table =
 558                         (*priv->ind_tables)[i];
 559
 560                 assert(ind_table != NULL);
 561                 claim_zero(ibv_exp_destroy_rwq_ind_table(ind_table));
 562         }
 563         priv->ind_tables_n = 0;
 564         rte_free(priv->ind_tables);
 565         priv->ind_tables = NULL;
 566 }
 567
 568 /**
 569  * Check whether a given flow type is allowed.
 570  *
 571  * @param priv
 572  *   Pointer to private structure.
 573  * @param type
 574  *   Flow type to check.
 575  *
 576  * @return
 577  *   Nonzero if the given flow type is allowed.
 578  */
 579 int
 580 priv_allow_flow_type(struct priv *priv, enum hash_rxq_flow_type type)
 581 {
 582         /* Only FLOW_TYPE_PROMISC is allowed when promiscuous mode
 583          * has been requested. */
 584         if (priv->promisc_req)
 585                 return type == HASH_RXQ_FLOW_TYPE_PROMISC;
 586         switch (type) {
 587         case HASH_RXQ_FLOW_TYPE_PROMISC:
 588                 return !!priv->promisc_req;
 589         case HASH_RXQ_FLOW_TYPE_ALLMULTI:
 590                 return !!priv->allmulti_req;
 591         case HASH_RXQ_FLOW_TYPE_BROADCAST:
 592 #ifdef HAVE_FLOW_SPEC_IPV6
 593         case HASH_RXQ_FLOW_TYPE_IPV6MULTI:
 594 #endif /* HAVE_FLOW_SPEC_IPV6 */
 595                 /* If allmulti is enabled, broadcast and ipv6multi
 596                  * are unnecessary. */
 597                 return !priv->allmulti_req;
 598         case HASH_RXQ_FLOW_TYPE_MAC:
 599                 return 1;
 600         default:
 601                 /* Unsupported flow type is not allowed. */
 602                 return 0;
 603         }
 604         return 0;
 605 }
 606
 607 /**
 608  * Automatically enable/disable flows according to configuration.
 609  *
 610  * @param priv
 611  *   Private structure.
 612  *
 613  * @return
 614  *   0 on success, errno value on failure.
 615  */
 616 int
 617 priv_rehash_flows(struct priv *priv)
 618 {
 619         unsigned int i;
 620
 621         for (i = 0; (i != RTE_DIM((*priv->hash_rxqs)[0].special_flow)); ++i)
 622                 if (!priv_allow_flow_type(priv, i)) {
 623                         priv_special_flow_disable(priv, i);
 624                 } else {
 625                         int ret = priv_special_flow_enable(priv, i);
 626
 627                         if (ret)
 628                                 return ret;
 629                 }
 630         if (priv_allow_flow_type(priv, HASH_RXQ_FLOW_TYPE_MAC))
 631                 return priv_mac_addrs_enable(priv);
 632         priv_mac_addrs_disable(priv);
 633         return 0;
 634 }
 635
 636 /**
 637  * Allocate RX queue elements.
 638  *
 639  * @param rxq
 640  *   Pointer to RX queue structure.
 641  * @param elts_n
 642  *   Number of elements to allocate.
 643  * @param[in] pool
 644  *   If not NULL, fetch buffers from this array instead of allocating them
 645  *   with rte_pktmbuf_alloc().
 646  *
 647  * @return
 648  *   0 on success, errno value on failure.
 649  */
 650 static int
 651 rxq_alloc_elts(struct rxq *rxq, unsigned int elts_n, struct rte_mbuf **pool)
 652 {
 653         unsigned int i;
 654         struct rxq_elt (*elts)[elts_n] =
 655                 rte_calloc_socket("RXQ elements", 1, sizeof(*elts), 0,
 656                                   rxq->socket);
 657         int ret = 0;
 658
 659         if (elts == NULL) {
 660                 ERROR("%p: can't allocate packets array", (void *)rxq);
 661                 ret = ENOMEM;
 662                 goto error;
 663         }
 664         /* For each WR (packet). */
 665         for (i = 0; (i != elts_n); ++i) {
 666                 struct rxq_elt *elt = &(*elts)[i];
 667                 struct ibv_sge *sge = &(*elts)[i].sge;
 668                 struct rte_mbuf *buf;
 669
 670                 if (pool != NULL) {
 671                         buf = *(pool++);
 672                         assert(buf != NULL);
 673                         rte_pktmbuf_reset(buf);
 674                 } else
 675                         buf = rte_pktmbuf_alloc(rxq->mp);
 676                 if (buf == NULL) {
 677                         assert(pool == NULL);
 678                         ERROR("%p: empty mbuf pool", (void *)rxq);
 679                         ret = ENOMEM;
 680                         goto error;
 681                 }
 682                 elt->buf = buf;
 683                 /* Headroom is reserved by rte_pktmbuf_alloc(). */
 684                 assert(DATA_OFF(buf) == RTE_PKTMBUF_HEADROOM);
 685                 /* Buffer is supposed to be empty. */
 686                 assert(rte_pktmbuf_data_len(buf) == 0);
 687                 assert(rte_pktmbuf_pkt_len(buf) == 0);
 688                 /* sge->addr must be able to store a pointer. */
 689                 assert(sizeof(sge->addr) >= sizeof(uintptr_t));
 690                 /* SGE keeps its headroom. */
 691                 sge->addr = (uintptr_t)
 692                         ((uint8_t *)buf->buf_addr + RTE_PKTMBUF_HEADROOM);
 693                 sge->length = (buf->buf_len - RTE_PKTMBUF_HEADROOM);
 694                 sge->lkey = rxq->mr->lkey;
 695                 /* Redundant check for tailroom. */
 696                 assert(sge->length == rte_pktmbuf_tailroom(buf));
 697         }
 698         DEBUG("%p: allocated and configured %u single-segment WRs",
 699               (void *)rxq, elts_n);
 700         rxq->elts_n = elts_n;
 701         rxq->elts_head = 0;
 702         rxq->elts = elts;
 703         assert(ret == 0);
 704         return 0;
 705 error:
 706         if (elts != NULL) {
 707                 assert(pool == NULL);
 708                 for (i = 0; (i != RTE_DIM(*elts)); ++i) {
 709                         struct rxq_elt *elt = &(*elts)[i];
 710                         struct rte_mbuf *buf = elt->buf;
 711
 712                         if (buf != NULL)
 713                                 rte_pktmbuf_free_seg(buf);
 714                 }
 715                 rte_free(elts);
 716         }
 717         DEBUG("%p: failed, freed everything", (void *)rxq);
 718         assert(ret > 0);
 719         return ret;
 720 }
 721
 722 /**
 723  * Free RX queue elements.
 724  *
 725  * @param rxq
 726  *   Pointer to RX queue structure.
 727  */
 728 static void
 729 rxq_free_elts(struct rxq *rxq)
 730 {
 731         unsigned int i;
 732         unsigned int elts_n = rxq->elts_n;
 733         struct rxq_elt (*elts)[elts_n] = rxq->elts;
 734
 735         DEBUG("%p: freeing WRs", (void *)rxq);
 736         rxq->elts_n = 0;
 737         rxq->elts = NULL;
 738         if (elts == NULL)
 739                 return;
 740         for (i = 0; (i != RTE_DIM(*elts)); ++i) {
 741                 struct rxq_elt *elt = &(*elts)[i];
 742                 struct rte_mbuf *buf = elt->buf;
 743
 744                 if (buf != NULL)
 745                         rte_pktmbuf_free_seg(buf);
 746         }
 747         rte_free(elts);
 748 }
 749
 750 /**
 751  * Clean up a RX queue.
 752  *
 753  * Destroy objects, free allocated memory and reset the structure for reuse.
 754  *
 755  * @param rxq
 756  *   Pointer to RX queue structure.
 757  */
 758 void
 759 rxq_cleanup(struct rxq *rxq)
 760 {
 761         struct ibv_exp_release_intf_params params;
 762
 763         DEBUG("cleaning up %p", (void *)rxq);
 764         rxq_free_elts(rxq);
 765         rxq->poll = NULL;
 766         rxq->recv = NULL;
 767         if (rxq->if_wq != NULL) {
 768                 assert(rxq->priv != NULL);
 769                 assert(rxq->priv->ctx != NULL);
 770                 assert(rxq->wq != NULL);
 771                 params = (struct ibv_exp_release_intf_params){
 772                         .comp_mask = 0,
 773                 };
 774                 claim_zero(ibv_exp_release_intf(rxq->priv->ctx,
 775                                                 rxq->if_wq,
 776                                                 &params));
 777         }
 778         if (rxq->if_cq != NULL) {
 779                 assert(rxq->priv != NULL);
 780                 assert(rxq->priv->ctx != NULL);
 781                 assert(rxq->cq != NULL);
 782                 params = (struct ibv_exp_release_intf_params){
 783                         .comp_mask = 0,
 784                 };
 785                 claim_zero(ibv_exp_release_intf(rxq->priv->ctx,
 786                                                 rxq->if_cq,
 787                                                 &params));
 788         }
 789         if (rxq->wq != NULL)
 790                 claim_zero(ibv_exp_destroy_wq(rxq->wq));
 791         if (rxq->cq != NULL)
 792                 claim_zero(ibv_destroy_cq(rxq->cq));
 793         if (rxq->rd != NULL) {
 794                 struct ibv_exp_destroy_res_domain_attr attr = {
 795                         .comp_mask = 0,
 796                 };
 797
 798                 assert(rxq->priv != NULL);
 799                 assert(rxq->priv->ctx != NULL);
 800                 claim_zero(ibv_exp_destroy_res_domain(rxq->priv->ctx,
 801                                                       rxq->rd,
 802                                                       &attr));
 803         }
 804         if (rxq->mr != NULL)
 805                 claim_zero(ibv_dereg_mr(rxq->mr));
 806         memset(rxq, 0, sizeof(*rxq));
 807 }
 808
 809 /**
 810  * Reconfigure a RX queue with new parameters.
 811  *
 812  * rxq_rehash() does not allocate mbufs, which, if not done from the right
 813  * thread (such as a control thread), may corrupt the pool.
 814  * In case of failure, the queue is left untouched.
 815  *
 816  * @param dev
 817  *   Pointer to Ethernet device structure.
 818  * @param rxq
 819  *   RX queue pointer.
 820  *
 821  * @return
 822  *   0 on success, errno value on failure.
 823  */
 824 int
 825 rxq_rehash(struct rte_eth_dev *dev, struct rxq *rxq)
 826 {
 827         struct priv *priv = rxq->priv;
 828         struct rxq tmpl = *rxq;
 829         unsigned int mbuf_n;
 830         unsigned int desc_n;
 831         struct rte_mbuf **pool;
 832         unsigned int i, k;
 833         struct ibv_exp_wq_attr mod;
 834         struct rxq_elt (*elts)[tmpl.elts_n];
 835         int err;
 836
 837         DEBUG("%p: rehashing queue %p", (void *)dev, (void *)rxq);
 838         /* Number of descriptors and mbufs currently allocated. */
 839         desc_n = tmpl.elts_n;
 840         mbuf_n = desc_n;
 841         /* Toggle RX checksum offload if hardware supports it. */
 842         if (priv->hw_csum) {
 843                 tmpl.csum = !!dev->data->dev_conf.rxmode.hw_ip_checksum;
 844                 rxq->csum = tmpl.csum;
 845         }
 846         if (priv->hw_csum_l2tun) {
 847                 tmpl.csum_l2tun = !!dev->data->dev_conf.rxmode.hw_ip_checksum;
 848                 rxq->csum_l2tun = tmpl.csum_l2tun;
 849         }
 850         /* From now on, any failure will render the queue unusable.
 851          * Reinitialize WQ. */
 852         mod = (struct ibv_exp_wq_attr){
 853                 .attr_mask = IBV_EXP_WQ_ATTR_STATE,
 854                 .wq_state = IBV_EXP_WQS_RESET,
 855         };
 856         err = ibv_exp_modify_wq(tmpl.wq, &mod);
 857         if (err) {
 858                 ERROR("%p: cannot reset WQ: %s", (void *)dev, strerror(err));
 859                 assert(err > 0);
 860                 return err;
 861         }
 862         /* Allocate pool. */
 863         pool = rte_malloc(__func__, (mbuf_n * sizeof(*pool)), 0);
 864         if (pool == NULL) {
 865                 ERROR("%p: cannot allocate memory", (void *)dev);
 866                 return ENOBUFS;
 867         }
 868         /* Snatch mbufs from original queue. */
 869         k = 0;
 870         elts = rxq->elts;
 871         for (i = 0; (i != RTE_DIM(*elts)); ++i) {
 872                 struct rxq_elt *elt = &(*elts)[i];
 873                 struct rte_mbuf *buf = elt->buf;
 874
 875                 pool[k++] = buf;
 876         }
 877         assert(k == mbuf_n);
 878         tmpl.elts_n = 0;
 879         tmpl.elts = NULL;
 880         assert((void *)&tmpl.elts == NULL);
 881         err = rxq_alloc_elts(&tmpl, desc_n, pool);
 882         if (err) {
 883                 ERROR("%p: cannot reallocate WRs, aborting", (void *)dev);
 884                 rte_free(pool);
 885                 assert(err > 0);
 886                 return err;
 887         }
 888         assert(tmpl.elts_n == desc_n);
 889         rte_free(pool);
 890         /* Clean up original data. */
 891         rxq->elts_n = 0;
 892         rte_free(rxq->elts);
 893         rxq->elts = NULL;
 894         /* Change queue state to ready. */
 895         mod = (struct ibv_exp_wq_attr){
 896                 .attr_mask = IBV_EXP_WQ_ATTR_STATE,
 897                 .wq_state = IBV_EXP_WQS_RDY,
 898         };
 899         err = ibv_exp_modify_wq(tmpl.wq, &mod);
 900         if (err) {
 901                 ERROR("%p: WQ state to IBV_EXP_WQS_RDY failed: %s",
 902                       (void *)dev, strerror(err));
 903                 goto error;
 904         }
 905         /* Post SGEs. */
 906         assert(tmpl.if_wq != NULL);
 907         elts = tmpl.elts;
 908         for (i = 0; (i != RTE_DIM(*elts)); ++i) {
 909                 err = tmpl.if_wq->recv_burst(
 910                         tmpl.wq,
 911                         &(*elts)[i].sge,
 912                         1);
 913                 if (err)
 914                         break;
 915         }
 916         if (err) {
 917                 ERROR("%p: failed to post SGEs with error %d",
 918                       (void *)dev, err);
 919                 /* Set err because it does not contain a valid errno value. */
 920                 err = EIO;
 921                 goto error;
 922         }
 923         tmpl.recv = tmpl.if_wq->recv_burst;
 924 error:
 925         *rxq = tmpl;
 926         assert(err >= 0);
 927         return err;
 928 }
 929
 930 /**
 931  * Configure a RX queue.
 932  *
 933  * @param dev
 934  *   Pointer to Ethernet device structure.
 935  * @param rxq
 936  *   Pointer to RX queue structure.
 937  * @param desc
 938  *   Number of descriptors to configure in queue.
 939  * @param socket
 940  *   NUMA socket on which memory must be allocated.
 941  * @param[in] conf
 942  *   Thresholds parameters.
 943  * @param mp
 944  *   Memory pool for buffer allocations.
 945  *
 946  * @return
 947  *   0 on success, errno value on failure.
 948  */
 949 int
 950 rxq_setup(struct rte_eth_dev *dev, struct rxq *rxq, uint16_t desc,
 951           unsigned int socket, const struct rte_eth_rxconf *conf,
 952           struct rte_mempool *mp)
 953 {
 954         struct priv *priv = dev->data->dev_private;
 955         struct rxq tmpl = {
 956                 .priv = priv,
 957                 .mp = mp,
 958                 .socket = socket
 959         };
 960         struct ibv_exp_wq_attr mod;
 961         union {
 962                 struct ibv_exp_query_intf_params params;
 963                 struct ibv_exp_cq_init_attr cq;
 964                 struct ibv_exp_res_domain_init_attr rd;
 965                 struct ibv_exp_wq_init_attr wq;
 966         } attr;
 967         enum ibv_exp_query_intf_status status;
 968         unsigned int mb_len = rte_pktmbuf_data_room_size(mp);
 969         struct rxq_elt (*elts)[desc];
 970         int ret = 0;
 971         unsigned int i;
 972         unsigned int cq_size = desc;
 973
 974         (void)conf; /* Thresholds configuration (ignored). */
 975         if (desc == 0) {
 976                 ERROR("%p: invalid number of RX descriptors", (void *)dev);
 977                 return EINVAL;
 978         }
 979         if (MLX5_PMD_SGE_WR_N > 1) {
 980                 ERROR("%p: RX scatter is not supported", (void *)dev);
 981                 return ENOTSUP;
 982         }
 983         /* Toggle RX checksum offload if hardware supports it. */
 984         if (priv->hw_csum)
 985                 tmpl.csum = !!dev->data->dev_conf.rxmode.hw_ip_checksum;
 986         if (priv->hw_csum_l2tun)
 987                 tmpl.csum_l2tun = !!dev->data->dev_conf.rxmode.hw_ip_checksum;
 988         (void)mb_len; /* I'll be back! */
 989         /* Use the entire RX mempool as the memory region. */
 990         tmpl.mr = mlx5_mp2mr(priv->pd, mp);
 991         if (tmpl.mr == NULL) {
 992                 ret = EINVAL;
 993                 ERROR("%p: MR creation failure: %s",
 994                       (void *)dev, strerror(ret));
 995                 goto error;
 996         }
 997         attr.rd = (struct ibv_exp_res_domain_init_attr){
 998                 .comp_mask = (IBV_EXP_RES_DOMAIN_THREAD_MODEL |
 999                               IBV_EXP_RES_DOMAIN_MSG_MODEL),
1000                 .thread_model = IBV_EXP_THREAD_SINGLE,
1001                 .msg_model = IBV_EXP_MSG_HIGH_BW,
1002         };
1003         tmpl.rd = ibv_exp_create_res_domain(priv->ctx, &attr.rd);
1004         if (tmpl.rd == NULL) {
1005                 ret = ENOMEM;
1006                 ERROR("%p: RD creation failure: %s",
1007                       (void *)dev, strerror(ret));
1008                 goto error;
1009         }
1010         attr.cq = (struct ibv_exp_cq_init_attr){
1011                 .comp_mask = IBV_EXP_CQ_INIT_ATTR_RES_DOMAIN,
1012                 .res_domain = tmpl.rd,
1013         };
1014         tmpl.cq = ibv_exp_create_cq(priv->ctx, cq_size, NULL, NULL, 0,
1015                                     &attr.cq);
1016         if (tmpl.cq == NULL) {
1017                 ret = ENOMEM;
1018                 ERROR("%p: CQ creation failure: %s",
1019                       (void *)dev, strerror(ret));
1020                 goto error;
1021         }
1022         DEBUG("priv->device_attr.max_qp_wr is %d",
1023               priv->device_attr.max_qp_wr);
1024         DEBUG("priv->device_attr.max_sge is %d",
1025               priv->device_attr.max_sge);
1026         /* Configure VLAN stripping. */
1027         tmpl.vlan_strip = (priv->hw_vlan_strip &&
1028                            !!dev->data->dev_conf.rxmode.hw_vlan_strip);
1029         attr.wq = (struct ibv_exp_wq_init_attr){
1030                 .wq_context = NULL, /* Could be useful in the future. */
1031                 .wq_type = IBV_EXP_WQT_RQ,
1032                 /* Max number of outstanding WRs. */
1033                 .max_recv_wr = ((priv->device_attr.max_qp_wr < (int)cq_size) ?
1034                                 priv->device_attr.max_qp_wr :
1035                                 (int)cq_size),
1036                 /* Max number of scatter/gather elements in a WR. */
1037                 .max_recv_sge = 1,
1038                 .pd = priv->pd,
1039                 .cq = tmpl.cq,
1040                 .comp_mask =
1041                         IBV_EXP_CREATE_WQ_RES_DOMAIN |
1042 #ifdef HAVE_EXP_DEVICE_ATTR_VLAN_OFFLOADS
1043                         IBV_EXP_CREATE_WQ_VLAN_OFFLOADS |
1044 #endif /* HAVE_EXP_DEVICE_ATTR_VLAN_OFFLOADS */
1045                         0,
1046                 .res_domain = tmpl.rd,
1047 #ifdef HAVE_EXP_DEVICE_ATTR_VLAN_OFFLOADS
1048                 .vlan_offloads = (tmpl.vlan_strip ?
1049                                   IBV_EXP_RECEIVE_WQ_CVLAN_STRIP :
1050                                   0),
1051 #endif /* HAVE_EXP_DEVICE_ATTR_VLAN_OFFLOADS */
1052         };
1053
1054 #ifdef HAVE_VERBS_FCS
1055         /* By default, FCS (CRC) is stripped by hardware. */
1056         if (dev->data->dev_conf.rxmode.hw_strip_crc) {
1057                 tmpl.crc_present = 0;
1058         } else if (priv->hw_fcs_strip) {
1059                 /* Ask HW/Verbs to leave CRC in place when supported. */
1060                 attr.wq.flags |= IBV_EXP_CREATE_WQ_FLAG_SCATTER_FCS;
1061                 attr.wq.comp_mask |= IBV_EXP_CREATE_WQ_FLAGS;
1062                 tmpl.crc_present = 1;
1063         } else {
1064                 WARN("%p: CRC stripping has been disabled but will still"
1065                      " be performed by hardware, make sure MLNX_OFED and"
1066                      " firmware are up to date",
1067                      (void *)dev);
1068                 tmpl.crc_present = 0;
1069         }
1070         DEBUG("%p: CRC stripping is %s, %u bytes will be subtracted from"
1071               " incoming frames to hide it",
1072               (void *)dev,
1073               tmpl.crc_present ? "disabled" : "enabled",
1074               tmpl.crc_present << 2);
1075 #endif /* HAVE_VERBS_FCS */
1076
1077 #ifdef HAVE_VERBS_RX_END_PADDING
1078         if (!mlx5_getenv_int("MLX5_PMD_ENABLE_PADDING"))
1079                 ; /* Nothing else to do. */
1080         else if (priv->hw_padding) {
1081                 INFO("%p: enabling packet padding on queue %p",
1082                      (void *)dev, (void *)rxq);
1083                 attr.wq.flags |= IBV_EXP_CREATE_WQ_FLAG_RX_END_PADDING;
1084                 attr.wq.comp_mask |= IBV_EXP_CREATE_WQ_FLAGS;
1085         } else
1086                 WARN("%p: packet padding has been requested but is not"
1087                      " supported, make sure MLNX_OFED and firmware are"
1088                      " up to date",
1089                      (void *)dev);
1090 #endif /* HAVE_VERBS_RX_END_PADDING */
1091
1092         tmpl.wq = ibv_exp_create_wq(priv->ctx, &attr.wq);
1093         if (tmpl.wq == NULL) {
1094                 ret = (errno ? errno : EINVAL);
1095                 ERROR("%p: WQ creation failure: %s",
1096                       (void *)dev, strerror(ret));
1097                 goto error;
1098         }
1099         ret = rxq_alloc_elts(&tmpl, desc, NULL);
1100         if (ret) {
1101                 ERROR("%p: RXQ allocation failed: %s",
1102                       (void *)dev, strerror(ret));
1103                 goto error;
1104         }
1105         /* Save port ID. */
1106         tmpl.port_id = dev->data->port_id;
1107         DEBUG("%p: RTE port ID: %u", (void *)rxq, tmpl.port_id);
1108         attr.params = (struct ibv_exp_query_intf_params){
1109                 .intf_scope = IBV_EXP_INTF_GLOBAL,
1110 #ifdef HAVE_EXP_DEVICE_ATTR_VLAN_OFFLOADS
1111                 .intf_version = 1,
1112 #endif /* HAVE_EXP_DEVICE_ATTR_VLAN_OFFLOADS */
1113                 .intf = IBV_EXP_INTF_CQ,
1114                 .obj = tmpl.cq,
1115         };
1116         tmpl.if_cq = ibv_exp_query_intf(priv->ctx, &attr.params, &status);
1117         if (tmpl.if_cq == NULL) {
1118                 ERROR("%p: CQ interface family query failed with status %d",
1119                       (void *)dev, status);
1120                 goto error;
1121         }
1122         attr.params = (struct ibv_exp_query_intf_params){
1123                 .intf_scope = IBV_EXP_INTF_GLOBAL,
1124                 .intf = IBV_EXP_INTF_WQ,
1125                 .obj = tmpl.wq,
1126         };
1127         tmpl.if_wq = ibv_exp_query_intf(priv->ctx, &attr.params, &status);
1128         if (tmpl.if_wq == NULL) {
1129                 ERROR("%p: WQ interface family query failed with status %d",
1130                       (void *)dev, status);
1131                 goto error;
1132         }
1133         /* Change queue state to ready. */
1134         mod = (struct ibv_exp_wq_attr){
1135                 .attr_mask = IBV_EXP_WQ_ATTR_STATE,
1136                 .wq_state = IBV_EXP_WQS_RDY,
1137         };
1138         ret = ibv_exp_modify_wq(tmpl.wq, &mod);
1139         if (ret) {
1140                 ERROR("%p: WQ state to IBV_EXP_WQS_RDY failed: %s",
1141                       (void *)dev, strerror(ret));
1142                 goto error;
1143         }
1144         /* Post SGEs. */
1145         elts = tmpl.elts;
1146         for (i = 0; (i != RTE_DIM(*elts)); ++i) {
1147                 ret = tmpl.if_wq->recv_burst(
1148                         tmpl.wq,
1149                         &(*elts)[i].sge,
1150                         1);
1151                 if (ret)
1152                         break;
1153         }
1154         if (ret) {
1155                 ERROR("%p: failed to post SGEs with error %d",
1156                       (void *)dev, ret);
1157                 /* Set ret because it does not contain a valid errno value. */
1158                 ret = EIO;
1159                 goto error;
1160         }
1161         /* Clean up rxq in case we're reinitializing it. */
1162         DEBUG("%p: cleaning-up old rxq just in case", (void *)rxq);
1163         rxq_cleanup(rxq);
1164         *rxq = tmpl;
1165         DEBUG("%p: rxq updated with %p", (void *)rxq, (void *)&tmpl);
1166         assert(ret == 0);
1167         /* Assign function in queue. */
1168 #ifdef HAVE_EXP_DEVICE_ATTR_VLAN_OFFLOADS
1169         rxq->poll = rxq->if_cq->poll_length_flags_cvlan;
1170 #else /* HAVE_EXP_DEVICE_ATTR_VLAN_OFFLOADS */
1171         rxq->poll = rxq->if_cq->poll_length_flags;
1172 #endif /* HAVE_EXP_DEVICE_ATTR_VLAN_OFFLOADS */
1173         rxq->recv = rxq->if_wq->recv_burst;
1174         return 0;
1175 error:
1176         rxq_cleanup(&tmpl);
1177         assert(ret > 0);
1178         return ret;
1179 }
1180
1181 /**
1182  * DPDK callback to configure a RX queue.
1183  *
1184  * @param dev
1185  *   Pointer to Ethernet device structure.
1186  * @param idx
1187  *   RX queue index.
1188  * @param desc
1189  *   Number of descriptors to configure in queue.
1190  * @param socket
1191  *   NUMA socket on which memory must be allocated.
1192  * @param[in] conf
1193  *   Thresholds parameters.
1194  * @param mp
1195  *   Memory pool for buffer allocations.
1196  *
1197  * @return
1198  *   0 on success, negative errno value on failure.
1199  */
1200 int
1201 mlx5_rx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t desc,
1202                     unsigned int socket, const struct rte_eth_rxconf *conf,
1203                     struct rte_mempool *mp)
1204 {
1205         struct priv *priv = dev->data->dev_private;
1206         struct rxq *rxq = (*priv->rxqs)[idx];
1207         int ret;
1208
1209         if (mlx5_is_secondary())
1210                 return -E_RTE_SECONDARY;
1211
1212         priv_lock(priv);
1213         DEBUG("%p: configuring queue %u for %u descriptors",
1214               (void *)dev, idx, desc);
1215         if (idx >= priv->rxqs_n) {
1216                 ERROR("%p: queue index out of range (%u >= %u)",
1217                       (void *)dev, idx, priv->rxqs_n);
1218                 priv_unlock(priv);
1219                 return -EOVERFLOW;
1220         }
1221         if (rxq != NULL) {
1222                 DEBUG("%p: reusing already allocated queue index %u (%p)",
1223                       (void *)dev, idx, (void *)rxq);
1224                 if (priv->started) {
1225                         priv_unlock(priv);
1226                         return -EEXIST;
1227                 }
1228                 (*priv->rxqs)[idx] = NULL;
1229                 rxq_cleanup(rxq);
1230         } else {
1231                 rxq = rte_calloc_socket("RXQ", 1, sizeof(*rxq), 0, socket);
1232                 if (rxq == NULL) {
1233                         ERROR("%p: unable to allocate queue index %u",
1234                               (void *)dev, idx);
1235                         priv_unlock(priv);
1236                         return -ENOMEM;
1237                 }
1238         }
1239         ret = rxq_setup(dev, rxq, desc, socket, conf, mp);
1240         if (ret)
1241                 rte_free(rxq);
1242         else {
1243                 rxq->stats.idx = idx;
1244                 DEBUG("%p: adding RX queue %p to list",
1245                       (void *)dev, (void *)rxq);
1246                 (*priv->rxqs)[idx] = rxq;
1247                 /* Update receive callback. */
1248                 dev->rx_pkt_burst = mlx5_rx_burst;
1249         }
1250         priv_unlock(priv);
1251         return -ret;
1252 }
1253
1254 /**
1255  * DPDK callback to release a RX queue.
1256  *
1257  * @param dpdk_rxq
1258  *   Generic RX queue pointer.
1259  */
1260 void
1261 mlx5_rx_queue_release(void *dpdk_rxq)
1262 {
1263         struct rxq *rxq = (struct rxq *)dpdk_rxq;
1264         struct priv *priv;
1265         unsigned int i;
1266
1267         if (mlx5_is_secondary())
1268                 return;
1269
1270         if (rxq == NULL)
1271                 return;
1272         priv = rxq->priv;
1273         priv_lock(priv);
1274         for (i = 0; (i != priv->rxqs_n); ++i)
1275                 if ((*priv->rxqs)[i] == rxq) {
1276                         DEBUG("%p: removing RX queue %p from list",
1277                               (void *)priv->dev, (void *)rxq);
1278                         (*priv->rxqs)[i] = NULL;
1279                         break;
1280                 }
1281         rxq_cleanup(rxq);
1282         rte_free(rxq);
1283         priv_unlock(priv);
1284 }
1285
1286 /**
1287  * DPDK callback for RX in secondary processes.
1288  *
1289  * This function configures all queues from primary process information
1290  * if necessary before reverting to the normal RX burst callback.
1291  *
1292  * @param dpdk_rxq
1293  *   Generic pointer to RX queue structure.
1294  * @param[out] pkts
1295  *   Array to store received packets.
1296  * @param pkts_n
1297  *   Maximum number of packets in array.
1298  *
1299  * @return
1300  *   Number of packets successfully received (<= pkts_n).
1301  */
1302 uint16_t
1303 mlx5_rx_burst_secondary_setup(void *dpdk_rxq, struct rte_mbuf **pkts,
1304                               uint16_t pkts_n)
1305 {
1306         struct rxq *rxq = dpdk_rxq;
1307         struct priv *priv = mlx5_secondary_data_setup(rxq->priv);
1308         struct priv *primary_priv;
1309         unsigned int index;
1310
1311         if (priv == NULL)
1312                 return 0;
1313         primary_priv =
1314                 mlx5_secondary_data[priv->dev->data->port_id].primary_priv;
1315         /* Look for queue index in both private structures. */
1316         for (index = 0; index != priv->rxqs_n; ++index)
1317                 if (((*primary_priv->rxqs)[index] == rxq) ||
1318                     ((*priv->rxqs)[index] == rxq))
1319                         break;
1320         if (index == priv->rxqs_n)
1321                 return 0;
1322         rxq = (*priv->rxqs)[index];
1323         return priv->dev->rx_pkt_burst(rxq, pkts, pkts_n);
1324 }