drivers/net/mlx5/mlx5_rxq.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2015 6WIND S.A.
   3  * Copyright 2015 Mellanox.
   4  */
   5
   6 #include <stddef.h>
   7 #include <assert.h>
   8 #include <errno.h>
   9 #include <string.h>
  10 #include <stdint.h>
  11 #include <fcntl.h>
  12 #include <sys/queue.h>
  13
  14 /* Verbs header. */
  15 /* ISO C doesn't support unnamed structs/unions, disabling -pedantic. */
  16 #ifdef PEDANTIC
  17 #pragma GCC diagnostic ignored "-Wpedantic"
  18 #endif
  19 #include <infiniband/verbs.h>
  20 #include <infiniband/mlx5dv.h>
  21 #ifdef PEDANTIC
  22 #pragma GCC diagnostic error "-Wpedantic"
  23 #endif
  24
  25 #include <rte_mbuf.h>
  26 #include <rte_malloc.h>
  27 #include <rte_ethdev_driver.h>
  28 #include <rte_common.h>
  29 #include <rte_interrupts.h>
  30 #include <rte_debug.h>
  31 #include <rte_io.h>
  32
  33 #include "mlx5.h"
  34 #include "mlx5_rxtx.h"
  35 #include "mlx5_utils.h"
  36 #include "mlx5_autoconf.h"
  37 #include "mlx5_defs.h"
  38 #include "mlx5_glue.h"
  39
  40 /* Default RSS hash key also used for ConnectX-3. */
  41 uint8_t rss_hash_default_key[] = {
  42         0x2c, 0xc6, 0x81, 0xd1,
  43         0x5b, 0xdb, 0xf4, 0xf7,
  44         0xfc, 0xa2, 0x83, 0x19,
  45         0xdb, 0x1a, 0x3e, 0x94,
  46         0x6b, 0x9e, 0x38, 0xd9,
  47         0x2c, 0x9c, 0x03, 0xd1,
  48         0xad, 0x99, 0x44, 0xa7,
  49         0xd9, 0x56, 0x3d, 0x59,
  50         0x06, 0x3c, 0x25, 0xf3,
  51         0xfc, 0x1f, 0xdc, 0x2a,
  52 };
  53
  54 /* Length of the default RSS hash key. */
  55 const size_t rss_hash_default_key_len = sizeof(rss_hash_default_key);
  56
  57 /**
  58  * Allocate RX queue elements.
  59  *
  60  * @param rxq_ctrl
  61  *   Pointer to RX queue structure.
  62  *
  63  * @return
  64  *   0 on success, errno value on failure.
  65  */
  66 int
  67 rxq_alloc_elts(struct mlx5_rxq_ctrl *rxq_ctrl)
  68 {
  69         const unsigned int sges_n = 1 << rxq_ctrl->rxq.sges_n;
  70         unsigned int elts_n = 1 << rxq_ctrl->rxq.elts_n;
  71         unsigned int i;
  72         int ret = 0;
  73
  74         /* Iterate on segments. */
  75         for (i = 0; (i != elts_n); ++i) {
  76                 struct rte_mbuf *buf;
  77
  78                 buf = rte_pktmbuf_alloc(rxq_ctrl->rxq.mp);
  79                 if (buf == NULL) {
  80                         ERROR("%p: empty mbuf pool", (void *)rxq_ctrl);
  81                         ret = ENOMEM;
  82                         goto error;
  83                 }
  84                 /* Headroom is reserved by rte_pktmbuf_alloc(). */
  85                 assert(DATA_OFF(buf) == RTE_PKTMBUF_HEADROOM);
  86                 /* Buffer is supposed to be empty. */
  87                 assert(rte_pktmbuf_data_len(buf) == 0);
  88                 assert(rte_pktmbuf_pkt_len(buf) == 0);
  89                 assert(!buf->next);
  90                 /* Only the first segment keeps headroom. */
  91                 if (i % sges_n)
  92                         SET_DATA_OFF(buf, 0);
  93                 PORT(buf) = rxq_ctrl->rxq.port_id;
  94                 DATA_LEN(buf) = rte_pktmbuf_tailroom(buf);
  95                 PKT_LEN(buf) = DATA_LEN(buf);
  96                 NB_SEGS(buf) = 1;
  97                 (*rxq_ctrl->rxq.elts)[i] = buf;
  98         }
  99         /* If Rx vector is activated. */
 100         if (mlx5_rxq_check_vec_support(&rxq_ctrl->rxq) > 0) {
 101                 struct mlx5_rxq_data *rxq = &rxq_ctrl->rxq;
 102                 struct rte_mbuf *mbuf_init = &rxq->fake_mbuf;
 103                 int j;
 104
 105                 /* Initialize default rearm_data for vPMD. */
 106                 mbuf_init->data_off = RTE_PKTMBUF_HEADROOM;
 107                 rte_mbuf_refcnt_set(mbuf_init, 1);
 108                 mbuf_init->nb_segs = 1;
 109                 mbuf_init->port = rxq->port_id;
 110                 /*
 111                  * prevent compiler reordering:
 112                  * rearm_data covers previous fields.
 113                  */
 114                 rte_compiler_barrier();
 115                 rxq->mbuf_initializer =
 116                         *(uint64_t *)&mbuf_init->rearm_data;
 117                 /* Padding with a fake mbuf for vectorized Rx. */
 118                 for (j = 0; j < MLX5_VPMD_DESCS_PER_LOOP; ++j)
 119                         (*rxq->elts)[elts_n + j] = &rxq->fake_mbuf;
 120         }
 121         DEBUG("%p: allocated and configured %u segments (max %u packets)",
 122               (void *)rxq_ctrl, elts_n, elts_n / (1 << rxq_ctrl->rxq.sges_n));
 123         assert(ret == 0);
 124         return 0;
 125 error:
 126         elts_n = i;
 127         for (i = 0; (i != elts_n); ++i) {
 128                 if ((*rxq_ctrl->rxq.elts)[i] != NULL)
 129                         rte_pktmbuf_free_seg((*rxq_ctrl->rxq.elts)[i]);
 130                 (*rxq_ctrl->rxq.elts)[i] = NULL;
 131         }
 132         DEBUG("%p: failed, freed everything", (void *)rxq_ctrl);
 133         assert(ret > 0);
 134         return ret;
 135 }
 136
 137 /**
 138  * Free RX queue elements.
 139  *
 140  * @param rxq_ctrl
 141  *   Pointer to RX queue structure.
 142  */
 143 static void
 144 rxq_free_elts(struct mlx5_rxq_ctrl *rxq_ctrl)
 145 {
 146         struct mlx5_rxq_data *rxq = &rxq_ctrl->rxq;
 147         const uint16_t q_n = (1 << rxq->elts_n);
 148         const uint16_t q_mask = q_n - 1;
 149         uint16_t used = q_n - (rxq->rq_ci - rxq->rq_pi);
 150         uint16_t i;
 151
 152         DEBUG("%p: freeing WRs", (void *)rxq_ctrl);
 153         if (rxq->elts == NULL)
 154                 return;
 155         /**
 156          * Some mbuf in the Ring belongs to the application.  They cannot be
 157          * freed.
 158          */
 159         if (mlx5_rxq_check_vec_support(rxq) > 0) {
 160                 for (i = 0; i < used; ++i)
 161                         (*rxq->elts)[(rxq->rq_ci + i) & q_mask] = NULL;
 162                 rxq->rq_pi = rxq->rq_ci;
 163         }
 164         for (i = 0; (i != (1u << rxq->elts_n)); ++i) {
 165                 if ((*rxq->elts)[i] != NULL)
 166                         rte_pktmbuf_free_seg((*rxq->elts)[i]);
 167                 (*rxq->elts)[i] = NULL;
 168         }
 169 }
 170
 171 /**
 172  * Clean up a RX queue.
 173  *
 174  * Destroy objects, free allocated memory and reset the structure for reuse.
 175  *
 176  * @param rxq_ctrl
 177  *   Pointer to RX queue structure.
 178  */
 179 void
 180 mlx5_rxq_cleanup(struct mlx5_rxq_ctrl *rxq_ctrl)
 181 {
 182         DEBUG("cleaning up %p", (void *)rxq_ctrl);
 183         if (rxq_ctrl->ibv)
 184                 mlx5_rxq_ibv_release(rxq_ctrl->ibv);
 185         memset(rxq_ctrl, 0, sizeof(*rxq_ctrl));
 186 }
 187
 188 /**
 189  * Returns the per-queue supported offloads.
 190  *
 191  * @param dev
 192  *   Pointer to Ethernet device.
 193  *
 194  * @return
 195  *   Supported Rx offloads.
 196  */
 197 uint64_t
 198 mlx5_get_rx_queue_offloads(struct rte_eth_dev *dev)
 199 {
 200         struct priv *priv = dev->data->dev_private;
 201         struct mlx5_dev_config *config = &priv->config;
 202         uint64_t offloads = (DEV_RX_OFFLOAD_SCATTER |
 203                              DEV_RX_OFFLOAD_TIMESTAMP |
 204                              DEV_RX_OFFLOAD_JUMBO_FRAME);
 205
 206         if (config->hw_fcs_strip)
 207                 offloads |= DEV_RX_OFFLOAD_CRC_STRIP;
 208         if (config->hw_csum)
 209                 offloads |= (DEV_RX_OFFLOAD_IPV4_CKSUM |
 210                              DEV_RX_OFFLOAD_UDP_CKSUM |
 211                              DEV_RX_OFFLOAD_TCP_CKSUM);
 212         if (config->hw_vlan_strip)
 213                 offloads |= DEV_RX_OFFLOAD_VLAN_STRIP;
 214         return offloads;
 215 }
 216
 217
 218 /**
 219  * Returns the per-port supported offloads.
 220  *
 221  * @return
 222  *   Supported Rx offloads.
 223  */
 224 uint64_t
 225 mlx5_get_rx_port_offloads(void)
 226 {
 227         uint64_t offloads = DEV_RX_OFFLOAD_VLAN_FILTER;
 228
 229         return offloads;
 230 }
 231
 232 /**
 233  * Checks if the per-queue offload configuration is valid.
 234  *
 235  * @param dev
 236  *   Pointer to Ethernet device.
 237  * @param offloads
 238  *   Per-queue offloads configuration.
 239  *
 240  * @return
 241  *   1 if the configuration is valid, 0 otherwise.
 242  */
 243 static int
 244 mlx5_is_rx_queue_offloads_allowed(struct rte_eth_dev *dev, uint64_t offloads)
 245 {
 246         uint64_t port_offloads = dev->data->dev_conf.rxmode.offloads;
 247         uint64_t queue_supp_offloads = mlx5_get_rx_queue_offloads(dev);
 248         uint64_t port_supp_offloads = mlx5_get_rx_port_offloads();
 249
 250         if ((offloads & (queue_supp_offloads | port_supp_offloads)) !=
 251             offloads)
 252                 return 0;
 253         if (((port_offloads ^ offloads) & port_supp_offloads))
 254                 return 0;
 255         return 1;
 256 }
 257
 258 /**
 259  *
 260  * @param dev
 261  *   Pointer to Ethernet device structure.
 262  * @param idx
 263  *   RX queue index.
 264  * @param desc
 265  *   Number of descriptors to configure in queue.
 266  * @param socket
 267  *   NUMA socket on which memory must be allocated.
 268  * @param[in] conf
 269  *   Thresholds parameters.
 270  * @param mp
 271  *   Memory pool for buffer allocations.
 272  *
 273  * @return
 274  *   0 on success, negative errno value on failure.
 275  */
 276 int
 277 mlx5_rx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t desc,
 278                     unsigned int socket, const struct rte_eth_rxconf *conf,
 279                     struct rte_mempool *mp)
 280 {
 281         struct priv *priv = dev->data->dev_private;
 282         struct mlx5_rxq_data *rxq = (*priv->rxqs)[idx];
 283         struct mlx5_rxq_ctrl *rxq_ctrl =
 284                 container_of(rxq, struct mlx5_rxq_ctrl, rxq);
 285         int ret = 0;
 286
 287         if (!rte_is_power_of_2(desc)) {
 288                 desc = 1 << log2above(desc);
 289                 WARN("%p: increased number of descriptors in RX queue %u"
 290                      " to the next power of two (%d)",
 291                      (void *)dev, idx, desc);
 292         }
 293         DEBUG("%p: configuring queue %u for %u descriptors",
 294               (void *)dev, idx, desc);
 295         if (idx >= priv->rxqs_n) {
 296                 ERROR("%p: queue index out of range (%u >= %u)",
 297                       (void *)dev, idx, priv->rxqs_n);
 298                 return -EOVERFLOW;
 299         }
 300         if (!mlx5_is_rx_queue_offloads_allowed(dev, conf->offloads)) {
 301                 ret = ENOTSUP;
 302                 ERROR("%p: Rx queue offloads 0x%" PRIx64 " don't match port "
 303                       "offloads 0x%" PRIx64 " or supported offloads 0x%" PRIx64,
 304                       (void *)dev, conf->offloads,
 305                       dev->data->dev_conf.rxmode.offloads,
 306                       (mlx5_get_rx_port_offloads() |
 307                        mlx5_get_rx_queue_offloads(dev)));
 308                 goto out;
 309         }
 310         if (!mlx5_rxq_releasable(dev, idx)) {
 311                 ret = EBUSY;
 312                 ERROR("%p: unable to release queue index %u",
 313                       (void *)dev, idx);
 314                 goto out;
 315         }
 316         mlx5_rxq_release(dev, idx);
 317         rxq_ctrl = mlx5_rxq_new(dev, idx, desc, socket, conf, mp);
 318         if (!rxq_ctrl) {
 319                 ERROR("%p: unable to allocate queue index %u",
 320                       (void *)dev, idx);
 321                 ret = ENOMEM;
 322                 goto out;
 323         }
 324         DEBUG("%p: adding RX queue %p to list",
 325               (void *)dev, (void *)rxq_ctrl);
 326         (*priv->rxqs)[idx] = &rxq_ctrl->rxq;
 327 out:
 328         return -ret;
 329 }
 330
 331 /**
 332  * DPDK callback to release a RX queue.
 333  *
 334  * @param dpdk_rxq
 335  *   Generic RX queue pointer.
 336  */
 337 void
 338 mlx5_rx_queue_release(void *dpdk_rxq)
 339 {
 340         struct mlx5_rxq_data *rxq = (struct mlx5_rxq_data *)dpdk_rxq;
 341         struct mlx5_rxq_ctrl *rxq_ctrl;
 342         struct priv *priv;
 343
 344         if (rxq == NULL)
 345                 return;
 346         rxq_ctrl = container_of(rxq, struct mlx5_rxq_ctrl, rxq);
 347         priv = rxq_ctrl->priv;
 348         if (!mlx5_rxq_releasable(priv->dev, rxq_ctrl->rxq.stats.idx))
 349                 rte_panic("Rx queue %p is still used by a flow and cannot be"
 350                           " removed\n", (void *)rxq_ctrl);
 351         mlx5_rxq_release(priv->dev, rxq_ctrl->rxq.stats.idx);
 352 }
 353
 354 /**
 355  * Allocate queue vector and fill epoll fd list for Rx interrupts.
 356  *
 357  * @param dev
 358  *   Pointer to Ethernet device.
 359  *
 360  * @return
 361  *   0 on success, negative on failure.
 362  */
 363 int
 364 mlx5_rx_intr_vec_enable(struct rte_eth_dev *dev)
 365 {
 366         struct priv *priv = dev->data->dev_private;
 367         unsigned int i;
 368         unsigned int rxqs_n = priv->rxqs_n;
 369         unsigned int n = RTE_MIN(rxqs_n, (uint32_t)RTE_MAX_RXTX_INTR_VEC_ID);
 370         unsigned int count = 0;
 371         struct rte_intr_handle *intr_handle = priv->dev->intr_handle;
 372
 373         if (!priv->dev->data->dev_conf.intr_conf.rxq)
 374                 return 0;
 375         mlx5_rx_intr_vec_disable(dev);
 376         intr_handle->intr_vec = malloc(n * sizeof(intr_handle->intr_vec[0]));
 377         if (intr_handle->intr_vec == NULL) {
 378                 ERROR("failed to allocate memory for interrupt vector,"
 379                       " Rx interrupts will not be supported");
 380                 return -ENOMEM;
 381         }
 382         intr_handle->type = RTE_INTR_HANDLE_EXT;
 383         for (i = 0; i != n; ++i) {
 384                 /* This rxq ibv must not be released in this function. */
 385                 struct mlx5_rxq_ibv *rxq_ibv = mlx5_rxq_ibv_get(dev, i);
 386                 int fd;
 387                 int flags;
 388                 int rc;
 389
 390                 /* Skip queues that cannot request interrupts. */
 391                 if (!rxq_ibv || !rxq_ibv->channel) {
 392                         /* Use invalid intr_vec[] index to disable entry. */
 393                         intr_handle->intr_vec[i] =
 394                                 RTE_INTR_VEC_RXTX_OFFSET +
 395                                 RTE_MAX_RXTX_INTR_VEC_ID;
 396                         continue;
 397                 }
 398                 if (count >= RTE_MAX_RXTX_INTR_VEC_ID) {
 399                         ERROR("too many Rx queues for interrupt vector size"
 400                               " (%d), Rx interrupts cannot be enabled",
 401                               RTE_MAX_RXTX_INTR_VEC_ID);
 402                         mlx5_rx_intr_vec_disable(dev);
 403                         return -1;
 404                 }
 405                 fd = rxq_ibv->channel->fd;
 406                 flags = fcntl(fd, F_GETFL);
 407                 rc = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 408                 if (rc < 0) {
 409                         ERROR("failed to make Rx interrupt file descriptor"
 410                               " %d non-blocking for queue index %d", fd, i);
 411                         mlx5_rx_intr_vec_disable(dev);
 412                         return -1;
 413                 }
 414                 intr_handle->intr_vec[i] = RTE_INTR_VEC_RXTX_OFFSET + count;
 415                 intr_handle->efds[count] = fd;
 416                 count++;
 417         }
 418         if (!count)
 419                 mlx5_rx_intr_vec_disable(dev);
 420         else
 421                 intr_handle->nb_efd = count;
 422         return 0;
 423 }
 424
 425 /**
 426  * Clean up Rx interrupts handler.
 427  *
 428  * @param dev
 429  *   Pointer to Ethernet device.
 430  */
 431 void
 432 mlx5_rx_intr_vec_disable(struct rte_eth_dev *dev)
 433 {
 434         struct priv *priv = dev->data->dev_private;
 435         struct rte_intr_handle *intr_handle = priv->dev->intr_handle;
 436         unsigned int i;
 437         unsigned int rxqs_n = priv->rxqs_n;
 438         unsigned int n = RTE_MIN(rxqs_n, (uint32_t)RTE_MAX_RXTX_INTR_VEC_ID);
 439
 440         if (!priv->dev->data->dev_conf.intr_conf.rxq)
 441                 return;
 442         if (!intr_handle->intr_vec)
 443                 goto free;
 444         for (i = 0; i != n; ++i) {
 445                 struct mlx5_rxq_ctrl *rxq_ctrl;
 446                 struct mlx5_rxq_data *rxq_data;
 447
 448                 if (intr_handle->intr_vec[i] == RTE_INTR_VEC_RXTX_OFFSET +
 449                     RTE_MAX_RXTX_INTR_VEC_ID)
 450                         continue;
 451                 /**
 452                  * Need to access directly the queue to release the reference
 453                  * kept in priv_rx_intr_vec_enable().
 454                  */
 455                 rxq_data = (*priv->rxqs)[i];
 456                 rxq_ctrl = container_of(rxq_data, struct mlx5_rxq_ctrl, rxq);
 457                 mlx5_rxq_ibv_release(rxq_ctrl->ibv);
 458         }
 459 free:
 460         rte_intr_free_epoll_fd(intr_handle);
 461         if (intr_handle->intr_vec)
 462                 free(intr_handle->intr_vec);
 463         intr_handle->nb_efd = 0;
 464         intr_handle->intr_vec = NULL;
 465 }
 466
 467 /**
 468  *  MLX5 CQ notification .
 469  *
 470  *  @param rxq
 471  *     Pointer to receive queue structure.
 472  *  @param sq_n_rxq
 473  *     Sequence number per receive queue .
 474  */
 475 static inline void
 476 mlx5_arm_cq(struct mlx5_rxq_data *rxq, int sq_n_rxq)
 477 {
 478         int sq_n = 0;
 479         uint32_t doorbell_hi;
 480         uint64_t doorbell;
 481         void *cq_db_reg = (char *)rxq->cq_uar + MLX5_CQ_DOORBELL;
 482
 483         sq_n = sq_n_rxq & MLX5_CQ_SQN_MASK;
 484         doorbell_hi = sq_n << MLX5_CQ_SQN_OFFSET | (rxq->cq_ci & MLX5_CI_MASK);
 485         doorbell = (uint64_t)doorbell_hi << 32;
 486         doorbell |=  rxq->cqn;
 487         rxq->cq_db[MLX5_CQ_ARM_DB] = rte_cpu_to_be_32(doorbell_hi);
 488         rte_write64(rte_cpu_to_be_64(doorbell), cq_db_reg);
 489 }
 490
 491 /**
 492  * DPDK callback for Rx queue interrupt enable.
 493  *
 494  * @param dev
 495  *   Pointer to Ethernet device structure.
 496  * @param rx_queue_id
 497  *   Rx queue number.
 498  *
 499  * @return
 500  *   0 on success, negative on failure.
 501  */
 502 int
 503 mlx5_rx_intr_enable(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 504 {
 505         struct priv *priv = dev->data->dev_private;
 506         struct mlx5_rxq_data *rxq_data;
 507         struct mlx5_rxq_ctrl *rxq_ctrl;
 508         int ret = 0;
 509
 510         rxq_data = (*priv->rxqs)[rx_queue_id];
 511         if (!rxq_data) {
 512                 ret = EINVAL;
 513                 goto exit;
 514         }
 515         rxq_ctrl = container_of(rxq_data, struct mlx5_rxq_ctrl, rxq);
 516         if (rxq_ctrl->irq) {
 517                 struct mlx5_rxq_ibv *rxq_ibv;
 518
 519                 rxq_ibv = mlx5_rxq_ibv_get(dev, rx_queue_id);
 520                 if (!rxq_ibv) {
 521                         ret = EINVAL;
 522                         goto exit;
 523                 }
 524                 mlx5_arm_cq(rxq_data, rxq_data->cq_arm_sn);
 525                 mlx5_rxq_ibv_release(rxq_ibv);
 526         }
 527 exit:
 528         if (ret)
 529                 WARN("unable to arm interrupt on rx queue %d", rx_queue_id);
 530         return -ret;
 531 }
 532
 533 /**
 534  * DPDK callback for Rx queue interrupt disable.
 535  *
 536  * @param dev
 537  *   Pointer to Ethernet device structure.
 538  * @param rx_queue_id
 539  *   Rx queue number.
 540  *
 541  * @return
 542  *   0 on success, negative on failure.
 543  */
 544 int
 545 mlx5_rx_intr_disable(struct rte_eth_dev *dev, uint16_t rx_queue_id)
 546 {
 547         struct priv *priv = dev->data->dev_private;
 548         struct mlx5_rxq_data *rxq_data;
 549         struct mlx5_rxq_ctrl *rxq_ctrl;
 550         struct mlx5_rxq_ibv *rxq_ibv = NULL;
 551         struct ibv_cq *ev_cq;
 552         void *ev_ctx;
 553         int ret = 0;
 554
 555         rxq_data = (*priv->rxqs)[rx_queue_id];
 556         if (!rxq_data) {
 557                 ret = EINVAL;
 558                 goto exit;
 559         }
 560         rxq_ctrl = container_of(rxq_data, struct mlx5_rxq_ctrl, rxq);
 561         if (!rxq_ctrl->irq)
 562                 goto exit;
 563         rxq_ibv = mlx5_rxq_ibv_get(dev, rx_queue_id);
 564         if (!rxq_ibv) {
 565                 ret = EINVAL;
 566                 goto exit;
 567         }
 568         ret = mlx5_glue->get_cq_event(rxq_ibv->channel, &ev_cq, &ev_ctx);
 569         if (ret || ev_cq != rxq_ibv->cq) {
 570                 ret = EINVAL;
 571                 goto exit;
 572         }
 573         rxq_data->cq_arm_sn++;
 574         mlx5_glue->ack_cq_events(rxq_ibv->cq, 1);
 575 exit:
 576         if (rxq_ibv)
 577                 mlx5_rxq_ibv_release(rxq_ibv);
 578         if (ret)
 579                 WARN("unable to disable interrupt on rx queue %d",
 580                      rx_queue_id);
 581         return -ret;
 582 }
 583
 584 /**
 585  * Create the Rx queue Verbs object.
 586  *
 587  * @param dev
 588  *   Pointer to Ethernet device.
 589  * @param idx
 590  *   Queue index in DPDK Rx queue array
 591  *
 592  * @return
 593  *   The Verbs object initialised if it can be created.
 594  */
 595 struct mlx5_rxq_ibv *
 596 mlx5_rxq_ibv_new(struct rte_eth_dev *dev, uint16_t idx)
 597 {
 598         struct priv *priv = dev->data->dev_private;
 599         struct mlx5_rxq_data *rxq_data = (*priv->rxqs)[idx];
 600         struct mlx5_rxq_ctrl *rxq_ctrl =
 601                 container_of(rxq_data, struct mlx5_rxq_ctrl, rxq);
 602         struct ibv_wq_attr mod;
 603         union {
 604                 struct {
 605                         struct ibv_cq_init_attr_ex ibv;
 606                         struct mlx5dv_cq_init_attr mlx5;
 607                 } cq;
 608                 struct ibv_wq_init_attr wq;
 609                 struct ibv_cq_ex cq_attr;
 610         } attr;
 611         unsigned int cqe_n = (1 << rxq_data->elts_n) - 1;
 612         struct mlx5_rxq_ibv *tmpl;
 613         struct mlx5dv_cq cq_info;
 614         struct mlx5dv_rwq rwq;
 615         unsigned int i;
 616         int ret = 0;
 617         struct mlx5dv_obj obj;
 618         struct mlx5_dev_config *config = &priv->config;
 619
 620         assert(rxq_data);
 621         assert(!rxq_ctrl->ibv);
 622         priv->verbs_alloc_ctx.type = MLX5_VERBS_ALLOC_TYPE_RX_QUEUE;
 623         priv->verbs_alloc_ctx.obj = rxq_ctrl;
 624         tmpl = rte_calloc_socket(__func__, 1, sizeof(*tmpl), 0,
 625                                  rxq_ctrl->socket);
 626         if (!tmpl) {
 627                 ERROR("%p: cannot allocate verbs resources",
 628                        (void *)rxq_ctrl);
 629                 goto error;
 630         }
 631         tmpl->rxq_ctrl = rxq_ctrl;
 632         /* Use the entire RX mempool as the memory region. */
 633         tmpl->mr = mlx5_mr_get(dev, rxq_data->mp);
 634         if (!tmpl->mr) {
 635                 tmpl->mr = mlx5_mr_new(dev, rxq_data->mp);
 636                 if (!tmpl->mr) {
 637                         ERROR("%p: MR creation failure", (void *)rxq_ctrl);
 638                         goto error;
 639                 }
 640         }
 641         if (rxq_ctrl->irq) {
 642                 tmpl->channel = mlx5_glue->create_comp_channel(priv->ctx);
 643                 if (!tmpl->channel) {
 644                         ERROR("%p: Comp Channel creation failure",
 645                               (void *)rxq_ctrl);
 646                         goto error;
 647                 }
 648         }
 649         attr.cq.ibv = (struct ibv_cq_init_attr_ex){
 650                 .cqe = cqe_n,
 651                 .channel = tmpl->channel,
 652                 .comp_mask = 0,
 653         };
 654         attr.cq.mlx5 = (struct mlx5dv_cq_init_attr){
 655                 .comp_mask = 0,
 656         };
 657         if (config->cqe_comp && !rxq_data->hw_timestamp) {
 658                 attr.cq.mlx5.comp_mask |=
 659                         MLX5DV_CQ_INIT_ATTR_MASK_COMPRESSED_CQE;
 660                 attr.cq.mlx5.cqe_comp_res_format = MLX5DV_CQE_RES_FORMAT_HASH;
 661                 /*
 662                  * For vectorized Rx, it must not be doubled in order to
 663                  * make cq_ci and rq_ci aligned.
 664                  */
 665                 if (mlx5_rxq_check_vec_support(rxq_data) < 0)
 666                         attr.cq.ibv.cqe *= 2;
 667         } else if (config->cqe_comp && rxq_data->hw_timestamp) {
 668                 DEBUG("Rx CQE compression is disabled for HW timestamp");
 669         }
 670         tmpl->cq = mlx5_glue->cq_ex_to_cq
 671                 (mlx5_glue->dv_create_cq(priv->ctx, &attr.cq.ibv,
 672                                          &attr.cq.mlx5));
 673         if (tmpl->cq == NULL) {
 674                 ERROR("%p: CQ creation failure", (void *)rxq_ctrl);
 675                 goto error;
 676         }
 677         DEBUG("priv->device_attr.max_qp_wr is %d",
 678               priv->device_attr.orig_attr.max_qp_wr);
 679         DEBUG("priv->device_attr.max_sge is %d",
 680               priv->device_attr.orig_attr.max_sge);
 681         attr.wq = (struct ibv_wq_init_attr){
 682                 .wq_context = NULL, /* Could be useful in the future. */
 683                 .wq_type = IBV_WQT_RQ,
 684                 /* Max number of outstanding WRs. */
 685                 .max_wr = (1 << rxq_data->elts_n) >> rxq_data->sges_n,
 686                 /* Max number of scatter/gather elements in a WR. */
 687                 .max_sge = 1 << rxq_data->sges_n,
 688                 .pd = priv->pd,
 689                 .cq = tmpl->cq,
 690                 .comp_mask =
 691                         IBV_WQ_FLAGS_CVLAN_STRIPPING |
 692                         0,
 693                 .create_flags = (rxq_data->vlan_strip ?
 694                                  IBV_WQ_FLAGS_CVLAN_STRIPPING :
 695                                  0),
 696         };
 697         /* By default, FCS (CRC) is stripped by hardware. */
 698         if (rxq_data->crc_present) {
 699                 attr.wq.create_flags |= IBV_WQ_FLAGS_SCATTER_FCS;
 700                 attr.wq.comp_mask |= IBV_WQ_INIT_ATTR_FLAGS;
 701         }
 702 #ifdef HAVE_IBV_WQ_FLAG_RX_END_PADDING
 703         if (config->hw_padding) {
 704                 attr.wq.create_flags |= IBV_WQ_FLAG_RX_END_PADDING;
 705                 attr.wq.comp_mask |= IBV_WQ_INIT_ATTR_FLAGS;
 706         }
 707 #endif
 708         tmpl->wq = mlx5_glue->create_wq(priv->ctx, &attr.wq);
 709         if (tmpl->wq == NULL) {
 710                 ERROR("%p: WQ creation failure", (void *)rxq_ctrl);
 711                 goto error;
 712         }
 713         /*
 714          * Make sure number of WRs*SGEs match expectations since a queue
 715          * cannot allocate more than "desc" buffers.
 716          */
 717         if (((int)attr.wq.max_wr !=
 718              ((1 << rxq_data->elts_n) >> rxq_data->sges_n)) ||
 719             ((int)attr.wq.max_sge != (1 << rxq_data->sges_n))) {
 720                 ERROR("%p: requested %u*%u but got %u*%u WRs*SGEs",
 721                       (void *)rxq_ctrl,
 722                       ((1 << rxq_data->elts_n) >> rxq_data->sges_n),
 723                       (1 << rxq_data->sges_n),
 724                       attr.wq.max_wr, attr.wq.max_sge);
 725                 goto error;
 726         }
 727         /* Change queue state to ready. */
 728         mod = (struct ibv_wq_attr){
 729                 .attr_mask = IBV_WQ_ATTR_STATE,
 730                 .wq_state = IBV_WQS_RDY,
 731         };
 732         ret = mlx5_glue->modify_wq(tmpl->wq, &mod);
 733         if (ret) {
 734                 ERROR("%p: WQ state to IBV_WQS_RDY failed",
 735                       (void *)rxq_ctrl);
 736                 goto error;
 737         }
 738         obj.cq.in = tmpl->cq;
 739         obj.cq.out = &cq_info;
 740         obj.rwq.in = tmpl->wq;
 741         obj.rwq.out = &rwq;
 742         ret = mlx5_glue->dv_init_obj(&obj, MLX5DV_OBJ_CQ | MLX5DV_OBJ_RWQ);
 743         if (ret != 0)
 744                 goto error;
 745         if (cq_info.cqe_size != RTE_CACHE_LINE_SIZE) {
 746                 ERROR("Wrong MLX5_CQE_SIZE environment variable value: "
 747                       "it should be set to %u", RTE_CACHE_LINE_SIZE);
 748                 goto error;
 749         }
 750         /* Fill the rings. */
 751         rxq_data->wqes = (volatile struct mlx5_wqe_data_seg (*)[])
 752                 (uintptr_t)rwq.buf;
 753         for (i = 0; (i != (unsigned int)(1 << rxq_data->elts_n)); ++i) {
 754                 struct rte_mbuf *buf = (*rxq_data->elts)[i];
 755                 volatile struct mlx5_wqe_data_seg *scat = &(*rxq_data->wqes)[i];
 756
 757                 /* scat->addr must be able to store a pointer. */
 758                 assert(sizeof(scat->addr) >= sizeof(uintptr_t));
 759                 *scat = (struct mlx5_wqe_data_seg){
 760                         .addr = rte_cpu_to_be_64(rte_pktmbuf_mtod(buf,
 761                                                                   uintptr_t)),
 762                         .byte_count = rte_cpu_to_be_32(DATA_LEN(buf)),
 763                         .lkey = tmpl->mr->lkey,
 764                 };
 765         }
 766         rxq_data->rq_db = rwq.dbrec;
 767         rxq_data->cqe_n = log2above(cq_info.cqe_cnt);
 768         rxq_data->cq_ci = 0;
 769         rxq_data->rq_ci = 0;
 770         rxq_data->rq_pi = 0;
 771         rxq_data->zip = (struct rxq_zip){
 772                 .ai = 0,
 773         };
 774         rxq_data->cq_db = cq_info.dbrec;
 775         rxq_data->cqes = (volatile struct mlx5_cqe (*)[])(uintptr_t)cq_info.buf;
 776         rxq_data->cq_uar = cq_info.cq_uar;
 777         rxq_data->cqn = cq_info.cqn;
 778         rxq_data->cq_arm_sn = 0;
 779         /* Update doorbell counter. */
 780         rxq_data->rq_ci = (1 << rxq_data->elts_n) >> rxq_data->sges_n;
 781         rte_wmb();
 782         *rxq_data->rq_db = rte_cpu_to_be_32(rxq_data->rq_ci);
 783         DEBUG("%p: rxq updated with %p", (void *)rxq_ctrl, (void *)&tmpl);
 784         rte_atomic32_inc(&tmpl->refcnt);
 785         DEBUG("%p: Verbs Rx queue %p: refcnt %d", (void *)dev,
 786               (void *)tmpl, rte_atomic32_read(&tmpl->refcnt));
 787         LIST_INSERT_HEAD(&priv->rxqsibv, tmpl, next);
 788         priv->verbs_alloc_ctx.type = MLX5_VERBS_ALLOC_TYPE_NONE;
 789         return tmpl;
 790 error:
 791         if (tmpl->wq)
 792                 claim_zero(mlx5_glue->destroy_wq(tmpl->wq));
 793         if (tmpl->cq)
 794                 claim_zero(mlx5_glue->destroy_cq(tmpl->cq));
 795         if (tmpl->channel)
 796                 claim_zero(mlx5_glue->destroy_comp_channel(tmpl->channel));
 797         if (tmpl->mr)
 798                 mlx5_mr_release(tmpl->mr);
 799         priv->verbs_alloc_ctx.type = MLX5_VERBS_ALLOC_TYPE_NONE;
 800         return NULL;
 801 }
 802
 803 /**
 804  * Get an Rx queue Verbs object.
 805  *
 806  * @param dev
 807  *   Pointer to Ethernet device.
 808  * @param idx
 809  *   Queue index in DPDK Rx queue array
 810  *
 811  * @return
 812  *   The Verbs object if it exists.
 813  */
 814 struct mlx5_rxq_ibv *
 815 mlx5_rxq_ibv_get(struct rte_eth_dev *dev, uint16_t idx)
 816 {
 817         struct priv *priv = dev->data->dev_private;
 818         struct mlx5_rxq_data *rxq_data = (*priv->rxqs)[idx];
 819         struct mlx5_rxq_ctrl *rxq_ctrl;
 820
 821         if (idx >= priv->rxqs_n)
 822                 return NULL;
 823         if (!rxq_data)
 824                 return NULL;
 825         rxq_ctrl = container_of(rxq_data, struct mlx5_rxq_ctrl, rxq);
 826         if (rxq_ctrl->ibv) {
 827                 mlx5_mr_get(dev, rxq_data->mp);
 828                 rte_atomic32_inc(&rxq_ctrl->ibv->refcnt);
 829                 DEBUG("%p: Verbs Rx queue %p: refcnt %d", (void *)dev,
 830                       (void *)rxq_ctrl->ibv,
 831                       rte_atomic32_read(&rxq_ctrl->ibv->refcnt));
 832         }
 833         return rxq_ctrl->ibv;
 834 }
 835
 836 /**
 837  * Release an Rx verbs queue object.
 838  *
 839  * @param rxq_ibv
 840  *   Verbs Rx queue object.
 841  *
 842  * @return
 843  *   0 on success, errno value on failure.
 844  */
 845 int
 846 mlx5_rxq_ibv_release(struct mlx5_rxq_ibv *rxq_ibv)
 847 {
 848         int ret;
 849
 850         assert(rxq_ibv);
 851         assert(rxq_ibv->wq);
 852         assert(rxq_ibv->cq);
 853         assert(rxq_ibv->mr);
 854         ret = mlx5_mr_release(rxq_ibv->mr);
 855         if (!ret)
 856                 rxq_ibv->mr = NULL;
 857         DEBUG("Verbs Rx queue %p: refcnt %d",
 858               (void *)rxq_ibv, rte_atomic32_read(&rxq_ibv->refcnt));
 859         if (rte_atomic32_dec_and_test(&rxq_ibv->refcnt)) {
 860                 rxq_free_elts(rxq_ibv->rxq_ctrl);
 861                 claim_zero(mlx5_glue->destroy_wq(rxq_ibv->wq));
 862                 claim_zero(mlx5_glue->destroy_cq(rxq_ibv->cq));
 863                 if (rxq_ibv->channel)
 864                         claim_zero(mlx5_glue->destroy_comp_channel
 865                                    (rxq_ibv->channel));
 866                 LIST_REMOVE(rxq_ibv, next);
 867                 rte_free(rxq_ibv);
 868                 return 0;
 869         }
 870         return EBUSY;
 871 }
 872
 873 /**
 874  * Verify the Verbs Rx queue list is empty
 875  *
 876  * @param dev
 877  *   Pointer to Ethernet device.
 878  *
 879  * @return
 880  *   The number of object not released.
 881  */
 882 int
 883 mlx5_rxq_ibv_verify(struct rte_eth_dev *dev)
 884 {
 885         struct priv *priv = dev->data->dev_private;
 886         int ret = 0;
 887         struct mlx5_rxq_ibv *rxq_ibv;
 888
 889         LIST_FOREACH(rxq_ibv, &priv->rxqsibv, next) {
 890                 DEBUG("%p: Verbs Rx queue %p still referenced", (void *)dev,
 891                       (void *)rxq_ibv);
 892                 ++ret;
 893         }
 894         return ret;
 895 }
 896
 897 /**
 898  * Return true if a single reference exists on the object.
 899  *
 900  * @param rxq_ibv
 901  *   Verbs Rx queue object.
 902  */
 903 int
 904 mlx5_rxq_ibv_releasable(struct mlx5_rxq_ibv *rxq_ibv)
 905 {
 906         assert(rxq_ibv);
 907         return (rte_atomic32_read(&rxq_ibv->refcnt) == 1);
 908 }
 909
 910 /**
 911  * Create a DPDK Rx queue.
 912  *
 913  * @param dev
 914  *   Pointer to Ethernet device.
 915  * @param idx
 916  *   TX queue index.
 917  * @param desc
 918  *   Number of descriptors to configure in queue.
 919  * @param socket
 920  *   NUMA socket on which memory must be allocated.
 921  *
 922  * @return
 923  *   A DPDK queue object on success.
 924  */
 925 struct mlx5_rxq_ctrl *
 926 mlx5_rxq_new(struct rte_eth_dev *dev, uint16_t idx, uint16_t desc,
 927              unsigned int socket, const struct rte_eth_rxconf *conf,
 928              struct rte_mempool *mp)
 929 {
 930         struct priv *priv = dev->data->dev_private;
 931         struct mlx5_rxq_ctrl *tmpl;
 932         unsigned int mb_len = rte_pktmbuf_data_room_size(mp);
 933         struct mlx5_dev_config *config = &priv->config;
 934         /*
 935          * Always allocate extra slots, even if eventually
 936          * the vector Rx will not be used.
 937          */
 938         const uint16_t desc_n =
 939                 desc + config->rx_vec_en * MLX5_VPMD_DESCS_PER_LOOP;
 940
 941         tmpl = rte_calloc_socket("RXQ", 1,
 942                                  sizeof(*tmpl) +
 943                                  desc_n * sizeof(struct rte_mbuf *),
 944                                  0, socket);
 945         if (!tmpl)
 946                 return NULL;
 947         tmpl->socket = socket;
 948         if (priv->dev->data->dev_conf.intr_conf.rxq)
 949                 tmpl->irq = 1;
 950         /* Enable scattered packets support for this queue if necessary. */
 951         assert(mb_len >= RTE_PKTMBUF_HEADROOM);
 952         if (dev->data->dev_conf.rxmode.max_rx_pkt_len <=
 953             (mb_len - RTE_PKTMBUF_HEADROOM)) {
 954                 tmpl->rxq.sges_n = 0;
 955         } else if (conf->offloads & DEV_RX_OFFLOAD_SCATTER) {
 956                 unsigned int size =
 957                         RTE_PKTMBUF_HEADROOM +
 958                         dev->data->dev_conf.rxmode.max_rx_pkt_len;
 959                 unsigned int sges_n;
 960
 961                 /*
 962                  * Determine the number of SGEs needed for a full packet
 963                  * and round it to the next power of two.
 964                  */
 965                 sges_n = log2above((size / mb_len) + !!(size % mb_len));
 966                 tmpl->rxq.sges_n = sges_n;
 967                 /* Make sure rxq.sges_n did not overflow. */
 968                 size = mb_len * (1 << tmpl->rxq.sges_n);
 969                 size -= RTE_PKTMBUF_HEADROOM;
 970                 if (size < dev->data->dev_conf.rxmode.max_rx_pkt_len) {
 971                         ERROR("%p: too many SGEs (%u) needed to handle"
 972                               " requested maximum packet size %u",
 973                               (void *)dev,
 974                               1 << sges_n,
 975                               dev->data->dev_conf.rxmode.max_rx_pkt_len);
 976                         goto error;
 977                 }
 978         } else {
 979                 WARN("%p: the requested maximum Rx packet size (%u) is"
 980                      " larger than a single mbuf (%u) and scattered"
 981                      " mode has not been requested",
 982                      (void *)dev,
 983                      dev->data->dev_conf.rxmode.max_rx_pkt_len,
 984                      mb_len - RTE_PKTMBUF_HEADROOM);
 985         }
 986         DEBUG("%p: maximum number of segments per packet: %u",
 987               (void *)dev, 1 << tmpl->rxq.sges_n);
 988         if (desc % (1 << tmpl->rxq.sges_n)) {
 989                 ERROR("%p: number of RX queue descriptors (%u) is not a"
 990                       " multiple of SGEs per packet (%u)",
 991                       (void *)dev,
 992                       desc,
 993                       1 << tmpl->rxq.sges_n);
 994                 goto error;
 995         }
 996         /* Toggle RX checksum offload if hardware supports it. */
 997         tmpl->rxq.csum = !!(conf->offloads & DEV_RX_OFFLOAD_CHECKSUM);
 998         tmpl->rxq.csum_l2tun = (!!(conf->offloads & DEV_RX_OFFLOAD_CHECKSUM) &&
 999                                 priv->config.tunnel_en);
1000         tmpl->rxq.hw_timestamp = !!(conf->offloads & DEV_RX_OFFLOAD_TIMESTAMP);
1001         /* Configure VLAN stripping. */
1002         tmpl->rxq.vlan_strip = !!(conf->offloads & DEV_RX_OFFLOAD_VLAN_STRIP);
1003         /* By default, FCS (CRC) is stripped by hardware. */
1004         if (conf->offloads & DEV_RX_OFFLOAD_CRC_STRIP) {
1005                 tmpl->rxq.crc_present = 0;
1006         } else if (config->hw_fcs_strip) {
1007                 tmpl->rxq.crc_present = 1;
1008         } else {
1009                 WARN("%p: CRC stripping has been disabled but will still"
1010                      " be performed by hardware, make sure MLNX_OFED and"
1011                      " firmware are up to date",
1012                      (void *)dev);
1013                 tmpl->rxq.crc_present = 0;
1014         }
1015         DEBUG("%p: CRC stripping is %s, %u bytes will be subtracted from"
1016               " incoming frames to hide it",
1017               (void *)dev,
1018               tmpl->rxq.crc_present ? "disabled" : "enabled",
1019               tmpl->rxq.crc_present << 2);
1020         /* Save port ID. */
1021         tmpl->rxq.rss_hash = priv->rxqs_n > 1;
1022         tmpl->rxq.port_id = dev->data->port_id;
1023         tmpl->priv = priv;
1024         tmpl->rxq.mp = mp;
1025         tmpl->rxq.stats.idx = idx;
1026         tmpl->rxq.elts_n = log2above(desc);
1027         tmpl->rxq.elts =
1028                 (struct rte_mbuf *(*)[1 << tmpl->rxq.elts_n])(tmpl + 1);
1029         rte_atomic32_inc(&tmpl->refcnt);
1030         DEBUG("%p: Rx queue %p: refcnt %d", (void *)dev,
1031               (void *)tmpl, rte_atomic32_read(&tmpl->refcnt));
1032         LIST_INSERT_HEAD(&priv->rxqsctrl, tmpl, next);
1033         return tmpl;
1034 error:
1035         rte_free(tmpl);
1036         return NULL;
1037 }
1038
1039 /**
1040  * Get a Rx queue.
1041  *
1042  * @param dev
1043  *   Pointer to Ethernet device.
1044  * @param idx
1045  *   TX queue index.
1046  *
1047  * @return
1048  *   A pointer to the queue if it exists.
1049  */
1050 struct mlx5_rxq_ctrl *
1051 mlx5_rxq_get(struct rte_eth_dev *dev, uint16_t idx)
1052 {
1053         struct priv *priv = dev->data->dev_private;
1054         struct mlx5_rxq_ctrl *rxq_ctrl = NULL;
1055
1056         if ((*priv->rxqs)[idx]) {
1057                 rxq_ctrl = container_of((*priv->rxqs)[idx],
1058                                         struct mlx5_rxq_ctrl,
1059                                         rxq);
1060                 mlx5_rxq_ibv_get(dev, idx);
1061                 rte_atomic32_inc(&rxq_ctrl->refcnt);
1062                 DEBUG("%p: Rx queue %p: refcnt %d", (void *)dev,
1063                       (void *)rxq_ctrl, rte_atomic32_read(&rxq_ctrl->refcnt));
1064         }
1065         return rxq_ctrl;
1066 }
1067
1068 /**
1069  * Release a Rx queue.
1070  *
1071  * @param dev
1072  *   Pointer to Ethernet device.
1073  * @param idx
1074  *   TX queue index.
1075  *
1076  * @return
1077  *   0 on success, errno value on failure.
1078  */
1079 int
1080 mlx5_rxq_release(struct rte_eth_dev *dev, uint16_t idx)
1081 {
1082         struct priv *priv = dev->data->dev_private;
1083         struct mlx5_rxq_ctrl *rxq_ctrl;
1084
1085         if (!(*priv->rxqs)[idx])
1086                 return 0;
1087         rxq_ctrl = container_of((*priv->rxqs)[idx], struct mlx5_rxq_ctrl, rxq);
1088         assert(rxq_ctrl->priv);
1089         if (rxq_ctrl->ibv) {
1090                 int ret;
1091
1092                 ret = mlx5_rxq_ibv_release(rxq_ctrl->ibv);
1093                 if (!ret)
1094                         rxq_ctrl->ibv = NULL;
1095         }
1096         DEBUG("%p: Rx queue %p: refcnt %d", (void *)dev,
1097               (void *)rxq_ctrl, rte_atomic32_read(&rxq_ctrl->refcnt));
1098         if (rte_atomic32_dec_and_test(&rxq_ctrl->refcnt)) {
1099                 LIST_REMOVE(rxq_ctrl, next);
1100                 rte_free(rxq_ctrl);
1101                 (*priv->rxqs)[idx] = NULL;
1102                 return 0;
1103         }
1104         return EBUSY;
1105 }
1106
1107 /**
1108  * Verify if the queue can be released.
1109  *
1110  * @param dev
1111  *   Pointer to Ethernet device.
1112  * @param idx
1113  *   TX queue index.
1114  *
1115  * @return
1116  *   1 if the queue can be released.
1117  */
1118 int
1119 mlx5_rxq_releasable(struct rte_eth_dev *dev, uint16_t idx)
1120 {
1121         struct priv *priv = dev->data->dev_private;
1122         struct mlx5_rxq_ctrl *rxq_ctrl;
1123
1124         if (!(*priv->rxqs)[idx])
1125                 return -1;
1126         rxq_ctrl = container_of((*priv->rxqs)[idx], struct mlx5_rxq_ctrl, rxq);
1127         return (rte_atomic32_read(&rxq_ctrl->refcnt) == 1);
1128 }
1129
1130 /**
1131  * Verify the Rx Queue list is empty
1132  *
1133  * @param dev
1134  *   Pointer to Ethernet device.
1135  *
1136  * @return
1137  *   The number of object not released.
1138  */
1139 int
1140 mlx5_rxq_verify(struct rte_eth_dev *dev)
1141 {
1142         struct priv *priv = dev->data->dev_private;
1143         struct mlx5_rxq_ctrl *rxq_ctrl;
1144         int ret = 0;
1145
1146         LIST_FOREACH(rxq_ctrl, &priv->rxqsctrl, next) {
1147                 DEBUG("%p: Rx Queue %p still referenced", (void *)dev,
1148                       (void *)rxq_ctrl);
1149                 ++ret;
1150         }
1151         return ret;
1152 }
1153
1154 /**
1155  * Create an indirection table.
1156  *
1157  * @param dev
1158  *   Pointer to Ethernet device.
1159  * @param queues
1160  *   Queues entering in the indirection table.
1161  * @param queues_n
1162  *   Number of queues in the array.
1163  *
1164  * @return
1165  *   A new indirection table.
1166  */
1167 struct mlx5_ind_table_ibv *
1168 mlx5_ind_table_ibv_new(struct rte_eth_dev *dev, uint16_t queues[],
1169                        uint16_t queues_n)
1170 {
1171         struct priv *priv = dev->data->dev_private;
1172         struct mlx5_ind_table_ibv *ind_tbl;
1173         const unsigned int wq_n = rte_is_power_of_2(queues_n) ?
1174                 log2above(queues_n) :
1175                 log2above(priv->config.ind_table_max_size);
1176         struct ibv_wq *wq[1 << wq_n];
1177         unsigned int i;
1178         unsigned int j;
1179
1180         ind_tbl = rte_calloc(__func__, 1, sizeof(*ind_tbl) +
1181                              queues_n * sizeof(uint16_t), 0);
1182         if (!ind_tbl)
1183                 return NULL;
1184         for (i = 0; i != queues_n; ++i) {
1185                 struct mlx5_rxq_ctrl *rxq = mlx5_rxq_get(dev, queues[i]);
1186
1187                 if (!rxq)
1188                         goto error;
1189                 wq[i] = rxq->ibv->wq;
1190                 ind_tbl->queues[i] = queues[i];
1191         }
1192         ind_tbl->queues_n = queues_n;
1193         /* Finalise indirection table. */
1194         for (j = 0; i != (unsigned int)(1 << wq_n); ++i, ++j)
1195                 wq[i] = wq[j];
1196         ind_tbl->ind_table = mlx5_glue->create_rwq_ind_table
1197                 (priv->ctx,
1198                  &(struct ibv_rwq_ind_table_init_attr){
1199                         .log_ind_tbl_size = wq_n,
1200                         .ind_tbl = wq,
1201                         .comp_mask = 0,
1202                  });
1203         if (!ind_tbl->ind_table)
1204                 goto error;
1205         rte_atomic32_inc(&ind_tbl->refcnt);
1206         LIST_INSERT_HEAD(&priv->ind_tbls, ind_tbl, next);
1207         DEBUG("%p: Indirection table %p: refcnt %d", (void *)dev,
1208               (void *)ind_tbl, rte_atomic32_read(&ind_tbl->refcnt));
1209         return ind_tbl;
1210 error:
1211         rte_free(ind_tbl);
1212         DEBUG("%p cannot create indirection table", (void *)dev);
1213         return NULL;
1214 }
1215
1216 /**
1217  * Get an indirection table.
1218  *
1219  * @param dev
1220  *   Pointer to Ethernet device.
1221  * @param queues
1222  *   Queues entering in the indirection table.
1223  * @param queues_n
1224  *   Number of queues in the array.
1225  *
1226  * @return
1227  *   An indirection table if found.
1228  */
1229 struct mlx5_ind_table_ibv *
1230 mlx5_ind_table_ibv_get(struct rte_eth_dev *dev, uint16_t queues[],
1231                        uint16_t queues_n)
1232 {
1233         struct priv *priv = dev->data->dev_private;
1234         struct mlx5_ind_table_ibv *ind_tbl;
1235
1236         LIST_FOREACH(ind_tbl, &priv->ind_tbls, next) {
1237                 if ((ind_tbl->queues_n == queues_n) &&
1238                     (memcmp(ind_tbl->queues, queues,
1239                             ind_tbl->queues_n * sizeof(ind_tbl->queues[0]))
1240                      == 0))
1241                         break;
1242         }
1243         if (ind_tbl) {
1244                 unsigned int i;
1245
1246                 rte_atomic32_inc(&ind_tbl->refcnt);
1247                 DEBUG("%p: Indirection table %p: refcnt %d", (void *)dev,
1248                       (void *)ind_tbl, rte_atomic32_read(&ind_tbl->refcnt));
1249                 for (i = 0; i != ind_tbl->queues_n; ++i)
1250                         mlx5_rxq_get(dev, ind_tbl->queues[i]);
1251         }
1252         return ind_tbl;
1253 }
1254
1255 /**
1256  * Release an indirection table.
1257  *
1258  * @param dev
1259  *   Pointer to Ethernet device.
1260  * @param ind_table
1261  *   Indirection table to release.
1262  *
1263  * @return
1264  *   0 on success, errno value on failure.
1265  */
1266 int
1267 mlx5_ind_table_ibv_release(struct rte_eth_dev *dev,
1268                            struct mlx5_ind_table_ibv *ind_tbl)
1269 {
1270         unsigned int i;
1271
1272         DEBUG("%p: Indirection table %p: refcnt %d", (void *)dev,
1273               (void *)ind_tbl, rte_atomic32_read(&ind_tbl->refcnt));
1274         if (rte_atomic32_dec_and_test(&ind_tbl->refcnt))
1275                 claim_zero(mlx5_glue->destroy_rwq_ind_table
1276                            (ind_tbl->ind_table));
1277         for (i = 0; i != ind_tbl->queues_n; ++i)
1278                 claim_nonzero(mlx5_rxq_release(dev, ind_tbl->queues[i]));
1279         if (!rte_atomic32_read(&ind_tbl->refcnt)) {
1280                 LIST_REMOVE(ind_tbl, next);
1281                 rte_free(ind_tbl);
1282                 return 0;
1283         }
1284         return EBUSY;
1285 }
1286
1287 /**
1288  * Verify the Rx Queue list is empty
1289  *
1290  * @param dev
1291  *   Pointer to Ethernet device.
1292  *
1293  * @return
1294  *   The number of object not released.
1295  */
1296 int
1297 mlx5_ind_table_ibv_verify(struct rte_eth_dev *dev)
1298 {
1299         struct priv *priv = dev->data->dev_private;
1300         struct mlx5_ind_table_ibv *ind_tbl;
1301         int ret = 0;
1302
1303         LIST_FOREACH(ind_tbl, &priv->ind_tbls, next) {
1304                 DEBUG("%p: Verbs indirection table %p still referenced",
1305                       (void *)dev, (void *)ind_tbl);
1306                 ++ret;
1307         }
1308         return ret;
1309 }
1310
1311 /**
1312  * Create an Rx Hash queue.
1313  *
1314  * @param dev
1315  *   Pointer to Ethernet device.
1316  * @param rss_key
1317  *   RSS key for the Rx hash queue.
1318  * @param rss_key_len
1319  *   RSS key length.
1320  * @param hash_fields
1321  *   Verbs protocol hash field to make the RSS on.
1322  * @param queues
1323  *   Queues entering in hash queue. In case of empty hash_fields only the
1324  *   first queue index will be taken for the indirection table.
1325  * @param queues_n
1326  *   Number of queues.
1327  *
1328  * @return
1329  *   An hash Rx queue on success.
1330  */
1331 struct mlx5_hrxq *
1332 mlx5_hrxq_new(struct rte_eth_dev *dev, uint8_t *rss_key, uint8_t rss_key_len,
1333               uint64_t hash_fields, uint16_t queues[], uint16_t queues_n)
1334 {
1335         struct priv *priv = dev->data->dev_private;
1336         struct mlx5_hrxq *hrxq;
1337         struct mlx5_ind_table_ibv *ind_tbl;
1338         struct ibv_qp *qp;
1339
1340         queues_n = hash_fields ? queues_n : 1;
1341         ind_tbl = mlx5_ind_table_ibv_get(dev, queues, queues_n);
1342         if (!ind_tbl)
1343                 ind_tbl = mlx5_ind_table_ibv_new(dev, queues, queues_n);
1344         if (!ind_tbl)
1345                 return NULL;
1346         qp = mlx5_glue->create_qp_ex
1347                 (priv->ctx,
1348                  &(struct ibv_qp_init_attr_ex){
1349                         .qp_type = IBV_QPT_RAW_PACKET,
1350                         .comp_mask =
1351                                 IBV_QP_INIT_ATTR_PD |
1352                                 IBV_QP_INIT_ATTR_IND_TABLE |
1353                                 IBV_QP_INIT_ATTR_RX_HASH,
1354                         .rx_hash_conf = (struct ibv_rx_hash_conf){
1355                                 .rx_hash_function = IBV_RX_HASH_FUNC_TOEPLITZ,
1356                                 .rx_hash_key_len = rss_key_len,
1357                                 .rx_hash_key = rss_key,
1358                                 .rx_hash_fields_mask = hash_fields,
1359                         },
1360                         .rwq_ind_tbl = ind_tbl->ind_table,
1361                         .pd = priv->pd,
1362                  });
1363         if (!qp)
1364                 goto error;
1365         hrxq = rte_calloc(__func__, 1, sizeof(*hrxq) + rss_key_len, 0);
1366         if (!hrxq)
1367                 goto error;
1368         hrxq->ind_table = ind_tbl;
1369         hrxq->qp = qp;
1370         hrxq->rss_key_len = rss_key_len;
1371         hrxq->hash_fields = hash_fields;
1372         memcpy(hrxq->rss_key, rss_key, rss_key_len);
1373         rte_atomic32_inc(&hrxq->refcnt);
1374         LIST_INSERT_HEAD(&priv->hrxqs, hrxq, next);
1375         DEBUG("%p: Hash Rx queue %p: refcnt %d", (void *)dev,
1376               (void *)hrxq, rte_atomic32_read(&hrxq->refcnt));
1377         return hrxq;
1378 error:
1379         mlx5_ind_table_ibv_release(dev, ind_tbl);
1380         if (qp)
1381                 claim_zero(mlx5_glue->destroy_qp(qp));
1382         return NULL;
1383 }
1384
1385 /**
1386  * Get an Rx Hash queue.
1387  *
1388  * @param dev
1389  *   Pointer to Ethernet device.
1390  * @param rss_conf
1391  *   RSS configuration for the Rx hash queue.
1392  * @param queues
1393  *   Queues entering in hash queue. In case of empty hash_fields only the
1394  *   first queue index will be taken for the indirection table.
1395  * @param queues_n
1396  *   Number of queues.
1397  *
1398  * @return
1399  *   An hash Rx queue on success.
1400  */
1401 struct mlx5_hrxq *
1402 mlx5_hrxq_get(struct rte_eth_dev *dev, uint8_t *rss_key, uint8_t rss_key_len,
1403               uint64_t hash_fields, uint16_t queues[], uint16_t queues_n)
1404 {
1405         struct priv *priv = dev->data->dev_private;
1406         struct mlx5_hrxq *hrxq;
1407
1408         queues_n = hash_fields ? queues_n : 1;
1409         LIST_FOREACH(hrxq, &priv->hrxqs, next) {
1410                 struct mlx5_ind_table_ibv *ind_tbl;
1411
1412                 if (hrxq->rss_key_len != rss_key_len)
1413                         continue;
1414                 if (memcmp(hrxq->rss_key, rss_key, rss_key_len))
1415                         continue;
1416                 if (hrxq->hash_fields != hash_fields)
1417                         continue;
1418                 ind_tbl = mlx5_ind_table_ibv_get(dev, queues, queues_n);
1419                 if (!ind_tbl)
1420                         continue;
1421                 if (ind_tbl != hrxq->ind_table) {
1422                         mlx5_ind_table_ibv_release(dev, ind_tbl);
1423                         continue;
1424                 }
1425                 rte_atomic32_inc(&hrxq->refcnt);
1426                 DEBUG("%p: Hash Rx queue %p: refcnt %d", (void *)dev,
1427                       (void *)hrxq, rte_atomic32_read(&hrxq->refcnt));
1428                 return hrxq;
1429         }
1430         return NULL;
1431 }
1432
1433 /**
1434  * Release the hash Rx queue.
1435  *
1436  * @param dev
1437  *   Pointer to Ethernet device.
1438  * @param hrxq
1439  *   Pointer to Hash Rx queue to release.
1440  *
1441  * @return
1442  *   0 on success, errno value on failure.
1443  */
1444 int
1445 mlx5_hrxq_release(struct rte_eth_dev *dev, struct mlx5_hrxq *hrxq)
1446 {
1447         DEBUG("%p: Hash Rx queue %p: refcnt %d", (void *)dev,
1448               (void *)hrxq, rte_atomic32_read(&hrxq->refcnt));
1449         if (rte_atomic32_dec_and_test(&hrxq->refcnt)) {
1450                 claim_zero(mlx5_glue->destroy_qp(hrxq->qp));
1451                 mlx5_ind_table_ibv_release(dev, hrxq->ind_table);
1452                 LIST_REMOVE(hrxq, next);
1453                 rte_free(hrxq);
1454                 return 0;
1455         }
1456         claim_nonzero(mlx5_ind_table_ibv_release(dev, hrxq->ind_table));
1457         return EBUSY;
1458 }
1459
1460 /**
1461  * Verify the Rx Queue list is empty
1462  *
1463  * @param dev
1464  *   Pointer to Ethernet device.
1465  *
1466  * @return
1467  *   The number of object not released.
1468  */
1469 int
1470 mlx5_hrxq_ibv_verify(struct rte_eth_dev *dev)
1471 {
1472         struct priv *priv = dev->data->dev_private;
1473         struct mlx5_hrxq *hrxq;
1474         int ret = 0;
1475
1476         LIST_FOREACH(hrxq, &priv->hrxqs, next) {
1477                 DEBUG("%p: Verbs Hash Rx queue %p still referenced",
1478                       (void *)dev, (void *)hrxq);
1479                 ++ret;
1480         }
1481         return ret;
1482 }