drivers/net/mlx4/mlx4_rxtx.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright 2017 6WIND S.A.
   5  *   Copyright 2017 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 /**
  35  * @file
  36  * Data plane functions for mlx4 driver.
  37  */
  38
  39 #include <assert.h>
  40 #include <inttypes.h>
  41 #include <stdint.h>
  42 #include <string.h>
  43
  44 /* Verbs headers do not support -pedantic. */
  45 #ifdef PEDANTIC
  46 #pragma GCC diagnostic ignored "-Wpedantic"
  47 #endif
  48 #include <infiniband/verbs.h>
  49 #ifdef PEDANTIC
  50 #pragma GCC diagnostic error "-Wpedantic"
  51 #endif
  52
  53 #include <rte_branch_prediction.h>
  54 #include <rte_common.h>
  55 #include <rte_io.h>
  56 #include <rte_mbuf.h>
  57 #include <rte_mempool.h>
  58 #include <rte_prefetch.h>
  59
  60 #include "mlx4.h"
  61 #include "mlx4_prm.h"
  62 #include "mlx4_rxtx.h"
  63 #include "mlx4_utils.h"
  64
  65 /**
  66  * Pointer-value pair structure used in tx_post_send for saving the first
  67  * DWORD (32 byte) of a TXBB.
  68  */
  69 struct pv {
  70         struct mlx4_wqe_data_seg *dseg;
  71         uint32_t val;
  72 };
  73
  74 /**
  75  * Stamp a WQE so it won't be reused by the HW.
  76  *
  77  * Routine is used when freeing WQE used by the chip or when failing
  78  * building an WQ entry has failed leaving partial information on the queue.
  79  *
  80  * @param sq
  81  *   Pointer to the SQ structure.
  82  * @param index
  83  *   Index of the freed WQE.
  84  * @param num_txbbs
  85  *   Number of blocks to stamp.
  86  *   If < 0 the routine will use the size written in the WQ entry.
  87  * @param owner
  88  *   The value of the WQE owner bit to use in the stamp.
  89  *
  90  * @return
  91  *   The number of Tx basic blocs (TXBB) the WQE contained.
  92  */
  93 static int
  94 mlx4_txq_stamp_freed_wqe(struct mlx4_sq *sq, uint16_t index, uint8_t owner)
  95 {
  96         uint32_t stamp = rte_cpu_to_be_32(MLX4_SQ_STAMP_VAL |
  97                                           (!!owner << MLX4_SQ_STAMP_SHIFT));
  98         uint8_t *wqe = mlx4_get_send_wqe(sq, (index & sq->txbb_cnt_mask));
  99         uint32_t *ptr = (uint32_t *)wqe;
 100         int i;
 101         int txbbs_size;
 102         int num_txbbs;
 103
 104         /* Extract the size from the control segment of the WQE. */
 105         num_txbbs = MLX4_SIZE_TO_TXBBS((((struct mlx4_wqe_ctrl_seg *)
 106                                          wqe)->fence_size & 0x3f) << 4);
 107         txbbs_size = num_txbbs * MLX4_TXBB_SIZE;
 108         /* Optimize the common case when there is no wrap-around. */
 109         if (wqe + txbbs_size <= sq->eob) {
 110                 /* Stamp the freed descriptor. */
 111                 for (i = 0; i < txbbs_size; i += MLX4_SQ_STAMP_STRIDE) {
 112                         *ptr = stamp;
 113                         ptr += MLX4_SQ_STAMP_DWORDS;
 114                 }
 115         } else {
 116                 /* Stamp the freed descriptor. */
 117                 for (i = 0; i < txbbs_size; i += MLX4_SQ_STAMP_STRIDE) {
 118                         *ptr = stamp;
 119                         ptr += MLX4_SQ_STAMP_DWORDS;
 120                         if ((uint8_t *)ptr >= sq->eob) {
 121                                 ptr = (uint32_t *)sq->buf;
 122                                 stamp ^= RTE_BE32(0x80000000);
 123                         }
 124                 }
 125         }
 126         return num_txbbs;
 127 }
 128
 129 /**
 130  * Manage Tx completions.
 131  *
 132  * When sending a burst, mlx4_tx_burst() posts several WRs.
 133  * To improve performance, a completion event is only required once every
 134  * MLX4_PMD_TX_PER_COMP_REQ sends. Doing so discards completion information
 135  * for other WRs, but this information would not be used anyway.
 136  *
 137  * @param txq
 138  *   Pointer to Tx queue structure.
 139  *
 140  * @return
 141  *   0 on success, -1 on failure.
 142  */
 143 static int
 144 mlx4_txq_complete(struct txq *txq)
 145 {
 146         unsigned int elts_comp = txq->elts_comp;
 147         unsigned int elts_tail = txq->elts_tail;
 148         const unsigned int elts_n = txq->elts_n;
 149         struct mlx4_cq *cq = &txq->mcq;
 150         struct mlx4_sq *sq = &txq->msq;
 151         struct mlx4_cqe *cqe;
 152         uint32_t cons_index = cq->cons_index;
 153         uint16_t new_index;
 154         uint16_t nr_txbbs = 0;
 155         int pkts = 0;
 156
 157         if (unlikely(elts_comp == 0))
 158                 return 0;
 159         /*
 160          * Traverse over all CQ entries reported and handle each WQ entry
 161          * reported by them.
 162          */
 163         do {
 164                 cqe = (struct mlx4_cqe *)mlx4_get_cqe(cq, cons_index);
 165                 if (unlikely(!!(cqe->owner_sr_opcode & MLX4_CQE_OWNER_MASK) ^
 166                     !!(cons_index & cq->cqe_cnt)))
 167                         break;
 168                 /*
 169                  * Make sure we read the CQE after we read the ownership bit.
 170                  */
 171                 rte_rmb();
 172                 if (unlikely((cqe->owner_sr_opcode & MLX4_CQE_OPCODE_MASK) ==
 173                              MLX4_CQE_OPCODE_ERROR)) {
 174                         struct mlx4_err_cqe *cqe_err =
 175                                 (struct mlx4_err_cqe *)cqe;
 176                         ERROR("%p CQE error - vendor syndrome: 0x%x"
 177                               " syndrome: 0x%x\n",
 178                               (void *)txq, cqe_err->vendor_err,
 179                               cqe_err->syndrome);
 180                 }
 181                 /* Get WQE index reported in the CQE. */
 182                 new_index =
 183                         rte_be_to_cpu_16(cqe->wqe_index) & sq->txbb_cnt_mask;
 184                 do {
 185                         /* Free next descriptor. */
 186                         nr_txbbs +=
 187                                 mlx4_txq_stamp_freed_wqe(sq,
 188                                      (sq->tail + nr_txbbs) & sq->txbb_cnt_mask,
 189                                      !!((sq->tail + nr_txbbs) & sq->txbb_cnt));
 190                         pkts++;
 191                 } while (((sq->tail + nr_txbbs) & sq->txbb_cnt_mask) !=
 192                          new_index);
 193                 cons_index++;
 194         } while (1);
 195         if (unlikely(pkts == 0))
 196                 return 0;
 197         /*
 198          * Update CQ.
 199          * To prevent CQ overflow we first update CQ consumer and only then
 200          * the ring consumer.
 201          */
 202         cq->cons_index = cons_index;
 203         *cq->set_ci_db = rte_cpu_to_be_32(cq->cons_index & 0xffffff);
 204         rte_wmb();
 205         sq->tail = sq->tail + nr_txbbs;
 206         /* Update the list of packets posted for transmission. */
 207         elts_comp -= pkts;
 208         assert(elts_comp <= txq->elts_comp);
 209         /*
 210          * Assume completion status is successful as nothing can be done about
 211          * it anyway.
 212          */
 213         elts_tail += pkts;
 214         if (elts_tail >= elts_n)
 215                 elts_tail -= elts_n;
 216         txq->elts_tail = elts_tail;
 217         txq->elts_comp = elts_comp;
 218         return 0;
 219 }
 220
 221 /**
 222  * Get memory pool (MP) from mbuf. If mbuf is indirect, the pool from which
 223  * the cloned mbuf is allocated is returned instead.
 224  *
 225  * @param buf
 226  *   Pointer to mbuf.
 227  *
 228  * @return
 229  *   Memory pool where data is located for given mbuf.
 230  */
 231 static struct rte_mempool *
 232 mlx4_txq_mb2mp(struct rte_mbuf *buf)
 233 {
 234         if (unlikely(RTE_MBUF_INDIRECT(buf)))
 235                 return rte_mbuf_from_indirect(buf)->pool;
 236         return buf->pool;
 237 }
 238
 239 /**
 240  * Get memory region (MR) <-> memory pool (MP) association from txq->mp2mr[].
 241  * Add MP to txq->mp2mr[] if it's not registered yet. If mp2mr[] is full,
 242  * remove an entry first.
 243  *
 244  * @param txq
 245  *   Pointer to Tx queue structure.
 246  * @param[in] mp
 247  *   Memory pool for which a memory region lkey must be returned.
 248  *
 249  * @return
 250  *   mr->lkey on success, (uint32_t)-1 on failure.
 251  */
 252 uint32_t
 253 mlx4_txq_mp2mr(struct txq *txq, struct rte_mempool *mp)
 254 {
 255         unsigned int i;
 256         struct ibv_mr *mr;
 257
 258         for (i = 0; (i != RTE_DIM(txq->mp2mr)); ++i) {
 259                 if (unlikely(txq->mp2mr[i].mp == NULL)) {
 260                         /* Unknown MP, add a new MR for it. */
 261                         break;
 262                 }
 263                 if (txq->mp2mr[i].mp == mp) {
 264                         assert(txq->mp2mr[i].lkey != (uint32_t)-1);
 265                         assert(txq->mp2mr[i].mr->lkey == txq->mp2mr[i].lkey);
 266                         return txq->mp2mr[i].lkey;
 267                 }
 268         }
 269         /* Add a new entry, register MR first. */
 270         DEBUG("%p: discovered new memory pool \"%s\" (%p)",
 271               (void *)txq, mp->name, (void *)mp);
 272         mr = mlx4_mp2mr(txq->priv->pd, mp);
 273         if (unlikely(mr == NULL)) {
 274                 DEBUG("%p: unable to configure MR, ibv_reg_mr() failed.",
 275                       (void *)txq);
 276                 return (uint32_t)-1;
 277         }
 278         if (unlikely(i == RTE_DIM(txq->mp2mr))) {
 279                 /* Table is full, remove oldest entry. */
 280                 DEBUG("%p: MR <-> MP table full, dropping oldest entry.",
 281                       (void *)txq);
 282                 --i;
 283                 claim_zero(ibv_dereg_mr(txq->mp2mr[0].mr));
 284                 memmove(&txq->mp2mr[0], &txq->mp2mr[1],
 285                         (sizeof(txq->mp2mr) - sizeof(txq->mp2mr[0])));
 286         }
 287         /* Store the new entry. */
 288         txq->mp2mr[i].mp = mp;
 289         txq->mp2mr[i].mr = mr;
 290         txq->mp2mr[i].lkey = mr->lkey;
 291         DEBUG("%p: new MR lkey for MP \"%s\" (%p): 0x%08" PRIu32,
 292               (void *)txq, mp->name, (void *)mp, txq->mp2mr[i].lkey);
 293         return txq->mp2mr[i].lkey;
 294 }
 295
 296 /**
 297  * Posts a single work request to a send queue.
 298  *
 299  * @param txq
 300  *   Target Tx queue.
 301  * @param pkt
 302  *   Packet to transmit.
 303  *
 304  * @return
 305  *   0 on success, negative errno value otherwise and rte_errno is set.
 306  */
 307 static inline int
 308 mlx4_post_send(struct txq *txq, struct rte_mbuf *pkt)
 309 {
 310         struct mlx4_wqe_ctrl_seg *ctrl;
 311         struct mlx4_wqe_data_seg *dseg;
 312         struct mlx4_sq *sq = &txq->msq;
 313         struct rte_mbuf *buf;
 314         uint32_t head_idx = sq->head & sq->txbb_cnt_mask;
 315         uint32_t lkey;
 316         uintptr_t addr;
 317         uint32_t srcrb_flags;
 318         uint32_t owner_opcode = MLX4_OPCODE_SEND;
 319         uint32_t byte_count;
 320         int wqe_real_size;
 321         int nr_txbbs;
 322         int rc;
 323         struct pv *pv = (struct pv *)txq->bounce_buf;
 324         int pv_counter = 0;
 325
 326         /* Calculate the needed work queue entry size for this packet. */
 327         wqe_real_size = sizeof(struct mlx4_wqe_ctrl_seg) +
 328                         pkt->nb_segs * sizeof(struct mlx4_wqe_data_seg);
 329         nr_txbbs = MLX4_SIZE_TO_TXBBS(wqe_real_size);
 330         /*
 331          * Check that there is room for this WQE in the send queue and that
 332          * the WQE size is legal.
 333          */
 334         if (((sq->head - sq->tail) + nr_txbbs +
 335              sq->headroom_txbbs) >= sq->txbb_cnt ||
 336             nr_txbbs > MLX4_MAX_WQE_TXBBS) {
 337                 rc = ENOSPC;
 338                 goto err;
 339         }
 340         /* Get the control and data entries of the WQE. */
 341         ctrl = (struct mlx4_wqe_ctrl_seg *)mlx4_get_send_wqe(sq, head_idx);
 342         dseg = (struct mlx4_wqe_data_seg *)((uintptr_t)ctrl +
 343                                             sizeof(struct mlx4_wqe_ctrl_seg));
 344         /* Fill the data segments with buffer information. */
 345         for (buf = pkt; buf != NULL; buf = buf->next, dseg++) {
 346                 addr = rte_pktmbuf_mtod(buf, uintptr_t);
 347                 rte_prefetch0((volatile void *)addr);
 348                 /* Handle WQE wraparound. */
 349                 if (unlikely(dseg >= (struct mlx4_wqe_data_seg *)sq->eob))
 350                         dseg = (struct mlx4_wqe_data_seg *)sq->buf;
 351                 dseg->addr = rte_cpu_to_be_64(addr);
 352                 /* Memory region key for this memory pool. */
 353                 lkey = mlx4_txq_mp2mr(txq, mlx4_txq_mb2mp(buf));
 354                 if (unlikely(lkey == (uint32_t)-1)) {
 355                         /* MR does not exist. */
 356                         DEBUG("%p: unable to get MP <-> MR association",
 357                               (void *)txq);
 358                         /*
 359                          * Restamp entry in case of failure.
 360                          * Make sure that size is written correctly
 361                          * Note that we give ownership to the SW, not the HW.
 362                          */
 363                         ctrl->fence_size = (wqe_real_size >> 4) & 0x3f;
 364                         mlx4_txq_stamp_freed_wqe(sq, head_idx,
 365                                      (sq->head & sq->txbb_cnt) ? 0 : 1);
 366                         rc = EFAULT;
 367                         goto err;
 368                 }
 369                 dseg->lkey = rte_cpu_to_be_32(lkey);
 370                 if (likely(buf->data_len)) {
 371                         byte_count = rte_cpu_to_be_32(buf->data_len);
 372                 } else {
 373                         /*
 374                          * Zero length segment is treated as inline segment
 375                          * with zero data.
 376                          */
 377                         byte_count = RTE_BE32(0x80000000);
 378                 }
 379                 /*
 380                  * If the data segment is not at the beginning of a
 381                  * Tx basic block (TXBB) then write the byte count,
 382                  * else postpone the writing to just before updating the
 383                  * control segment.
 384                  */
 385                 if ((uintptr_t)dseg & (uintptr_t)(MLX4_TXBB_SIZE - 1)) {
 386                         /*
 387                          * Need a barrier here before writing the byte_count
 388                          * fields to make sure that all the data is visible
 389                          * before the byte_count field is set.
 390                          * Otherwise, if the segment begins a new cacheline,
 391                          * the HCA prefetcher could grab the 64-byte chunk and
 392                          * get a valid (!= 0xffffffff) byte count but stale
 393                          * data, and end up sending the wrong data.
 394                          */
 395                         rte_io_wmb();
 396                         dseg->byte_count = byte_count;
 397                 } else {
 398                         /*
 399                          * This data segment starts at the beginning of a new
 400                          * TXBB, so we need to postpone its byte_count writing
 401                          * for later.
 402                          */
 403                         pv[pv_counter].dseg = dseg;
 404                         pv[pv_counter++].val = byte_count;
 405                 }
 406         }
 407         /* Write the first DWORD of each TXBB save earlier. */
 408         if (pv_counter) {
 409                 /* Need a barrier here before writing the byte_count. */
 410                 rte_io_wmb();
 411                 for (--pv_counter; pv_counter  >= 0; pv_counter--)
 412                         pv[pv_counter].dseg->byte_count = pv[pv_counter].val;
 413         }
 414         /* Fill the control parameters for this packet. */
 415         ctrl->fence_size = (wqe_real_size >> 4) & 0x3f;
 416         /*
 417          * The caller should prepare "imm" in advance in order to support
 418          * VF to VF communication (when the device is a virtual-function
 419          * device (VF)).
 420          */
 421         ctrl->imm = 0;
 422         /*
 423          * For raw Ethernet, the SOLICIT flag is used to indicate that no ICRC
 424          * should be calculated.
 425          */
 426         txq->elts_comp_cd -= nr_txbbs;
 427         if (unlikely(txq->elts_comp_cd <= 0)) {
 428                 txq->elts_comp_cd = txq->elts_comp_cd_init;
 429                 srcrb_flags = RTE_BE32(MLX4_WQE_CTRL_SOLICIT |
 430                                        MLX4_WQE_CTRL_CQ_UPDATE);
 431         } else {
 432                 srcrb_flags = RTE_BE32(MLX4_WQE_CTRL_SOLICIT);
 433         }
 434         ctrl->srcrb_flags = srcrb_flags;
 435         /*
 436          * Make sure descriptor is fully written before
 437          * setting ownership bit (because HW can start
 438          * executing as soon as we do).
 439          */
 440         rte_wmb();
 441         ctrl->owner_opcode = rte_cpu_to_be_32(owner_opcode |
 442                                               ((sq->head & sq->txbb_cnt) ?
 443                                                MLX4_BIT_WQE_OWN : 0));
 444         sq->head += nr_txbbs;
 445         return 0;
 446 err:
 447         rte_errno = rc;
 448         return -rc;
 449 }
 450
 451 /**
 452  * DPDK callback for Tx.
 453  *
 454  * @param dpdk_txq
 455  *   Generic pointer to Tx queue structure.
 456  * @param[in] pkts
 457  *   Packets to transmit.
 458  * @param pkts_n
 459  *   Number of packets in array.
 460  *
 461  * @return
 462  *   Number of packets successfully transmitted (<= pkts_n).
 463  */
 464 uint16_t
 465 mlx4_tx_burst(void *dpdk_txq, struct rte_mbuf **pkts, uint16_t pkts_n)
 466 {
 467         struct txq *txq = (struct txq *)dpdk_txq;
 468         unsigned int elts_head = txq->elts_head;
 469         const unsigned int elts_n = txq->elts_n;
 470         unsigned int elts_comp = 0;
 471         unsigned int bytes_sent = 0;
 472         unsigned int i;
 473         unsigned int max;
 474         int err;
 475
 476         assert(txq->elts_comp_cd != 0);
 477         mlx4_txq_complete(txq);
 478         max = (elts_n - (elts_head - txq->elts_tail));
 479         if (max > elts_n)
 480                 max -= elts_n;
 481         assert(max >= 1);
 482         assert(max <= elts_n);
 483         /* Always leave one free entry in the ring. */
 484         --max;
 485         if (max == 0)
 486                 return 0;
 487         if (max > pkts_n)
 488                 max = pkts_n;
 489         for (i = 0; (i != max); ++i) {
 490                 struct rte_mbuf *buf = pkts[i];
 491                 unsigned int elts_head_next =
 492                         (((elts_head + 1) == elts_n) ? 0 : elts_head + 1);
 493                 struct txq_elt *elt_next = &(*txq->elts)[elts_head_next];
 494                 struct txq_elt *elt = &(*txq->elts)[elts_head];
 495
 496                 /* Clean up old buffer. */
 497                 if (likely(elt->buf != NULL)) {
 498                         struct rte_mbuf *tmp = elt->buf;
 499
 500 #ifndef NDEBUG
 501                         /* Poisoning. */
 502                         memset(elt, 0x66, sizeof(*elt));
 503 #endif
 504                         /* Faster than rte_pktmbuf_free(). */
 505                         do {
 506                                 struct rte_mbuf *next = tmp->next;
 507
 508                                 rte_pktmbuf_free_seg(tmp);
 509                                 tmp = next;
 510                         } while (tmp != NULL);
 511                 }
 512                 RTE_MBUF_PREFETCH_TO_FREE(elt_next->buf);
 513                 /* Post the packet for sending. */
 514                 err = mlx4_post_send(txq, buf);
 515                 if (unlikely(err)) {
 516                         elt->buf = NULL;
 517                         goto stop;
 518                 }
 519                 elt->buf = buf;
 520                 bytes_sent += buf->pkt_len;
 521                 ++elts_comp;
 522                 elts_head = elts_head_next;
 523         }
 524 stop:
 525         /* Take a shortcut if nothing must be sent. */
 526         if (unlikely(i == 0))
 527                 return 0;
 528         /* Increment send statistics counters. */
 529         txq->stats.opackets += i;
 530         txq->stats.obytes += bytes_sent;
 531         /* Make sure that descriptors are written before doorbell record. */
 532         rte_wmb();
 533         /* Ring QP doorbell. */
 534         rte_write32(txq->msq.doorbell_qpn, txq->msq.db);
 535         txq->elts_head = elts_head;
 536         txq->elts_comp += elts_comp;
 537         return i;
 538 }
 539
 540 /**
 541  * DPDK callback for Rx.
 542  *
 543  * The following function doesn't manage scattered packets.
 544  *
 545  * @param dpdk_rxq
 546  *   Generic pointer to Rx queue structure.
 547  * @param[out] pkts
 548  *   Array to store received packets.
 549  * @param pkts_n
 550  *   Maximum number of packets in array.
 551  *
 552  * @return
 553  *   Number of packets successfully received (<= pkts_n).
 554  */
 555 uint16_t
 556 mlx4_rx_burst(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
 557 {
 558         struct rxq *rxq = (struct rxq *)dpdk_rxq;
 559         struct rxq_elt (*elts)[rxq->elts_n] = rxq->elts;
 560         const unsigned int elts_n = rxq->elts_n;
 561         unsigned int elts_head = rxq->elts_head;
 562         struct ibv_wc wcs[pkts_n];
 563         struct ibv_recv_wr *wr_head = NULL;
 564         struct ibv_recv_wr **wr_next = &wr_head;
 565         struct ibv_recv_wr *wr_bad = NULL;
 566         unsigned int i;
 567         unsigned int pkts_ret = 0;
 568         int ret;
 569
 570         ret = ibv_poll_cq(rxq->cq, pkts_n, wcs);
 571         if (unlikely(ret == 0))
 572                 return 0;
 573         if (unlikely(ret < 0)) {
 574                 DEBUG("rxq=%p, ibv_poll_cq() failed (wc_n=%d)",
 575                       (void *)rxq, ret);
 576                 return 0;
 577         }
 578         assert(ret <= (int)pkts_n);
 579         /* For each work completion. */
 580         for (i = 0; i != (unsigned int)ret; ++i) {
 581                 struct ibv_wc *wc = &wcs[i];
 582                 struct rxq_elt *elt = &(*elts)[elts_head];
 583                 struct ibv_recv_wr *wr = &elt->wr;
 584                 uint32_t len = wc->byte_len;
 585                 struct rte_mbuf *seg = elt->buf;
 586                 struct rte_mbuf *rep;
 587
 588                 /* Sanity checks. */
 589                 assert(wr->sg_list == &elt->sge);
 590                 assert(wr->num_sge == 1);
 591                 assert(elts_head < rxq->elts_n);
 592                 assert(rxq->elts_head < rxq->elts_n);
 593                 /*
 594                  * Fetch initial bytes of packet descriptor into a
 595                  * cacheline while allocating rep.
 596                  */
 597                 rte_mbuf_prefetch_part1(seg);
 598                 rte_mbuf_prefetch_part2(seg);
 599                 /* Link completed WRs together for repost. */
 600                 *wr_next = wr;
 601                 wr_next = &wr->next;
 602                 if (unlikely(wc->status != IBV_WC_SUCCESS)) {
 603                         /* Whatever, just repost the offending WR. */
 604                         DEBUG("rxq=%p: bad work completion status (%d): %s",
 605                               (void *)rxq, wc->status,
 606                               ibv_wc_status_str(wc->status));
 607                         /* Increment dropped packets counter. */
 608                         ++rxq->stats.idropped;
 609                         goto repost;
 610                 }
 611                 rep = rte_mbuf_raw_alloc(rxq->mp);
 612                 if (unlikely(rep == NULL)) {
 613                         /*
 614                          * Unable to allocate a replacement mbuf,
 615                          * repost WR.
 616                          */
 617                         DEBUG("rxq=%p: can't allocate a new mbuf",
 618                               (void *)rxq);
 619                         /* Increase out of memory counters. */
 620                         ++rxq->stats.rx_nombuf;
 621                         ++rxq->priv->dev->data->rx_mbuf_alloc_failed;
 622                         goto repost;
 623                 }
 624                 /* Reconfigure sge to use rep instead of seg. */
 625                 elt->sge.addr = (uintptr_t)rep->buf_addr + RTE_PKTMBUF_HEADROOM;
 626                 assert(elt->sge.lkey == rxq->mr->lkey);
 627                 elt->buf = rep;
 628                 /* Update seg information. */
 629                 seg->data_off = RTE_PKTMBUF_HEADROOM;
 630                 seg->nb_segs = 1;
 631                 seg->port = rxq->port_id;
 632                 seg->next = NULL;
 633                 seg->pkt_len = len;
 634                 seg->data_len = len;
 635                 seg->packet_type = 0;
 636                 seg->ol_flags = 0;
 637                 /* Return packet. */
 638                 *(pkts++) = seg;
 639                 ++pkts_ret;
 640                 /* Increase bytes counter. */
 641                 rxq->stats.ibytes += len;
 642 repost:
 643                 if (++elts_head >= elts_n)
 644                         elts_head = 0;
 645                 continue;
 646         }
 647         if (unlikely(i == 0))
 648                 return 0;
 649         /* Repost WRs. */
 650         *wr_next = NULL;
 651         assert(wr_head);
 652         ret = ibv_post_wq_recv(rxq->wq, wr_head, &wr_bad);
 653         if (unlikely(ret)) {
 654                 /* Inability to repost WRs is fatal. */
 655                 DEBUG("%p: recv_burst(): failed (ret=%d)",
 656                       (void *)rxq->priv,
 657                       ret);
 658                 abort();
 659         }
 660         rxq->elts_head = elts_head;
 661         /* Increase packets counter. */
 662         rxq->stats.ipackets += pkts_ret;
 663         return pkts_ret;
 664 }
 665
 666 /**
 667  * Dummy DPDK callback for Tx.
 668  *
 669  * This function is used to temporarily replace the real callback during
 670  * unsafe control operations on the queue, or in case of error.
 671  *
 672  * @param dpdk_txq
 673  *   Generic pointer to Tx queue structure.
 674  * @param[in] pkts
 675  *   Packets to transmit.
 676  * @param pkts_n
 677  *   Number of packets in array.
 678  *
 679  * @return
 680  *   Number of packets successfully transmitted (<= pkts_n).
 681  */
 682 uint16_t
 683 mlx4_tx_burst_removed(void *dpdk_txq, struct rte_mbuf **pkts, uint16_t pkts_n)
 684 {
 685         (void)dpdk_txq;
 686         (void)pkts;
 687         (void)pkts_n;
 688         return 0;
 689 }
 690
 691 /**
 692  * Dummy DPDK callback for Rx.
 693  *
 694  * This function is used to temporarily replace the real callback during
 695  * unsafe control operations on the queue, or in case of error.
 696  *
 697  * @param dpdk_rxq
 698  *   Generic pointer to Rx queue structure.
 699  * @param[out] pkts
 700  *   Array to store received packets.
 701  * @param pkts_n
 702  *   Maximum number of packets in array.
 703  *
 704  * @return
 705  *   Number of packets successfully received (<= pkts_n).
 706  */
 707 uint16_t
 708 mlx4_rx_burst_removed(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
 709 {
 710         (void)dpdk_rxq;
 711         (void)pkts;
 712         (void)pkts_n;
 713         return 0;
 714 }