drivers/net/mlx4/mlx4_rxq.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  * Rx queues configuration for mlx4 driver.
  37  */
  38
  39 #include <assert.h>
  40 #include <errno.h>
  41 #include <stddef.h>
  42 #include <stdint.h>
  43 #include <string.h>
  44
  45 /* Verbs headers do not support -pedantic. */
  46 #ifdef PEDANTIC
  47 #pragma GCC diagnostic ignored "-Wpedantic"
  48 #endif
  49 #include <infiniband/verbs.h>
  50 #ifdef PEDANTIC
  51 #pragma GCC diagnostic error "-Wpedantic"
  52 #endif
  53
  54 #include <rte_common.h>
  55 #include <rte_errno.h>
  56 #include <rte_ethdev.h>
  57 #include <rte_flow.h>
  58 #include <rte_malloc.h>
  59 #include <rte_mbuf.h>
  60 #include <rte_mempool.h>
  61
  62 #include "mlx4.h"
  63 #include "mlx4_flow.h"
  64 #include "mlx4_rxtx.h"
  65 #include "mlx4_utils.h"
  66
  67 /**
  68  * Historical RSS hash key.
  69  *
  70  * This used to be the default for mlx4 in Linux before v3.19 switched to
  71  * generating random hash keys through netdev_rss_key_fill().
  72  *
  73  * It is used in this PMD for consistency with past DPDK releases but can
  74  * now be overridden through user configuration.
  75  *
  76  * Note: this is not const to work around API quirks.
  77  */
  78 uint8_t
  79 mlx4_rss_hash_key_default[MLX4_RSS_HASH_KEY_SIZE] = {
  80         0x2c, 0xc6, 0x81, 0xd1,
  81         0x5b, 0xdb, 0xf4, 0xf7,
  82         0xfc, 0xa2, 0x83, 0x19,
  83         0xdb, 0x1a, 0x3e, 0x94,
  84         0x6b, 0x9e, 0x38, 0xd9,
  85         0x2c, 0x9c, 0x03, 0xd1,
  86         0xad, 0x99, 0x44, 0xa7,
  87         0xd9, 0x56, 0x3d, 0x59,
  88         0x06, 0x3c, 0x25, 0xf3,
  89         0xfc, 0x1f, 0xdc, 0x2a,
  90 };
  91
  92 /**
  93  * Obtain a RSS context with specified properties.
  94  *
  95  * Used when creating a flow rule targeting one or several Rx queues.
  96  *
  97  * If a matching RSS context already exists, it is returned with its
  98  * reference count incremented.
  99  *
 100  * @param priv
 101  *   Pointer to private structure.
 102  * @param fields
 103  *   Fields for RSS processing (Verbs format).
 104  * @param[in] key
 105  *   Hash key to use (whose size is exactly MLX4_RSS_HASH_KEY_SIZE).
 106  * @param queues
 107  *   Number of target queues.
 108  * @param[in] queue_id
 109  *   Target queues.
 110  *
 111  * @return
 112  *   Pointer to RSS context on success, NULL otherwise and rte_errno is set.
 113  */
 114 struct mlx4_rss *
 115 mlx4_rss_get(struct priv *priv, uint64_t fields,
 116              uint8_t key[MLX4_RSS_HASH_KEY_SIZE],
 117              uint16_t queues, const uint16_t queue_id[])
 118 {
 119         struct mlx4_rss *rss;
 120         size_t queue_id_size = sizeof(queue_id[0]) * queues;
 121
 122         LIST_FOREACH(rss, &priv->rss, next)
 123                 if (fields == rss->fields &&
 124                     queues == rss->queues &&
 125                     !memcmp(key, rss->key, MLX4_RSS_HASH_KEY_SIZE) &&
 126                     !memcmp(queue_id, rss->queue_id, queue_id_size)) {
 127                         ++rss->refcnt;
 128                         return rss;
 129                 }
 130         rss = rte_malloc(__func__, offsetof(struct mlx4_rss, queue_id) +
 131                          queue_id_size, 0);
 132         if (!rss)
 133                 goto error;
 134         *rss = (struct mlx4_rss){
 135                 .priv = priv,
 136                 .refcnt = 1,
 137                 .usecnt = 0,
 138                 .qp = NULL,
 139                 .ind = NULL,
 140                 .fields = fields,
 141                 .queues = queues,
 142         };
 143         memcpy(rss->key, key, MLX4_RSS_HASH_KEY_SIZE);
 144         memcpy(rss->queue_id, queue_id, queue_id_size);
 145         LIST_INSERT_HEAD(&priv->rss, rss, next);
 146         return rss;
 147 error:
 148         rte_errno = ENOMEM;
 149         return NULL;
 150 }
 151
 152 /**
 153  * Release a RSS context instance.
 154  *
 155  * Used when destroying a flow rule targeting one or several Rx queues.
 156  *
 157  * This function decrements the reference count of the context and destroys
 158  * it after reaching 0. The context must have no users at this point; all
 159  * prior calls to mlx4_rss_attach() must have been followed by matching
 160  * calls to mlx4_rss_detach().
 161  *
 162  * @param rss
 163  *   RSS context to release.
 164  */
 165 void mlx4_rss_put(struct mlx4_rss *rss)
 166 {
 167         assert(rss->refcnt);
 168         if (--rss->refcnt)
 169                 return;
 170         assert(!rss->usecnt);
 171         assert(!rss->qp);
 172         assert(!rss->ind);
 173         LIST_REMOVE(rss, next);
 174         rte_free(rss);
 175 }
 176
 177 /**
 178  * Attach a user to a RSS context instance.
 179  *
 180  * Used when the RSS QP and indirection table objects must be instantiated,
 181  * that is, when a flow rule must be enabled.
 182  *
 183  * This function increments the usage count of the context.
 184  *
 185  * @param rss
 186  *   RSS context to attach to.
 187  */
 188 int mlx4_rss_attach(struct mlx4_rss *rss)
 189 {
 190         assert(rss->refcnt);
 191         if (rss->usecnt++) {
 192                 assert(rss->qp);
 193                 assert(rss->ind);
 194                 return 0;
 195         }
 196
 197         struct ibv_wq *ind_tbl[rss->queues];
 198         struct priv *priv = rss->priv;
 199         const char *msg;
 200         unsigned int i;
 201         int ret;
 202
 203         if (!rte_is_power_of_2(RTE_DIM(ind_tbl))) {
 204                 msg = "number of RSS queues must be a power of two";
 205                 goto error;
 206         }
 207         for (i = 0; i != RTE_DIM(ind_tbl); ++i) {
 208                 uint16_t id = rss->queue_id[i];
 209                 struct rxq *rxq = NULL;
 210
 211                 if (id < priv->dev->data->nb_rx_queues)
 212                         rxq = priv->dev->data->rx_queues[id];
 213                 if (!rxq) {
 214                         msg = "RSS target queue is not configured";
 215                         goto error;
 216                 }
 217                 ind_tbl[i] = rxq->wq;
 218         }
 219         rss->ind = ibv_create_rwq_ind_table
 220                 (priv->ctx,
 221                  &(struct ibv_rwq_ind_table_init_attr){
 222                         .log_ind_tbl_size = rte_log2_u32(RTE_DIM(ind_tbl)),
 223                         .ind_tbl = ind_tbl,
 224                         .comp_mask = 0,
 225                  });
 226         if (!rss->ind) {
 227                 msg = "RSS indirection table creation failure";
 228                 goto error;
 229         }
 230         rss->qp = ibv_create_qp_ex
 231                 (priv->ctx,
 232                  &(struct ibv_qp_init_attr_ex){
 233                         .comp_mask = (IBV_QP_INIT_ATTR_PD |
 234                                       IBV_QP_INIT_ATTR_RX_HASH |
 235                                       IBV_QP_INIT_ATTR_IND_TABLE),
 236                         .qp_type = IBV_QPT_RAW_PACKET,
 237                         .pd = priv->pd,
 238                         .rwq_ind_tbl = rss->ind,
 239                         .rx_hash_conf = {
 240                                 .rx_hash_function = IBV_RX_HASH_FUNC_TOEPLITZ,
 241                                 .rx_hash_key_len = MLX4_RSS_HASH_KEY_SIZE,
 242                                 .rx_hash_key = rss->key,
 243                                 .rx_hash_fields_mask = rss->fields,
 244                         },
 245                  });
 246         if (!rss->qp) {
 247                 msg = "RSS hash QP creation failure";
 248                 goto error;
 249         }
 250         ret = ibv_modify_qp
 251                 (rss->qp,
 252                  &(struct ibv_qp_attr){
 253                         .qp_state = IBV_QPS_INIT,
 254                         .port_num = priv->port,
 255                  },
 256                  IBV_QP_STATE | IBV_QP_PORT);
 257         if (ret) {
 258                 msg = "failed to switch RSS hash QP to INIT state";
 259                 goto error;
 260         }
 261         ret = ibv_modify_qp
 262                 (rss->qp,
 263                  &(struct ibv_qp_attr){
 264                         .qp_state = IBV_QPS_RTR,
 265                  },
 266                  IBV_QP_STATE);
 267         if (ret) {
 268                 msg = "failed to switch RSS hash QP to RTR state";
 269                 goto error;
 270         }
 271         return 0;
 272 error:
 273         ERROR("mlx4: %s", msg);
 274         --rss->usecnt;
 275         rte_errno = EINVAL;
 276         return -rte_errno;
 277 }
 278
 279 /**
 280  * Detach a user from a RSS context instance.
 281  *
 282  * Used when disabling (not destroying) a flow rule.
 283  *
 284  * This function decrements the usage count of the context and destroys
 285  * usage resources after reaching 0.
 286  *
 287  * @param rss
 288  *   RSS context to detach from.
 289  */
 290 void mlx4_rss_detach(struct mlx4_rss *rss)
 291 {
 292         assert(rss->refcnt);
 293         assert(rss->qp);
 294         assert(rss->ind);
 295         if (--rss->usecnt)
 296                 return;
 297         claim_zero(ibv_destroy_qp(rss->qp));
 298         rss->qp = NULL;
 299         claim_zero(ibv_destroy_rwq_ind_table(rss->ind));
 300         rss->ind = NULL;
 301 }
 302
 303 /**
 304  * Allocate Rx queue elements.
 305  *
 306  * @param rxq
 307  *   Pointer to Rx queue structure.
 308  *
 309  * @return
 310  *   0 on success, negative errno value otherwise and rte_errno is set.
 311  */
 312 static int
 313 mlx4_rxq_alloc_elts(struct rxq *rxq)
 314 {
 315         struct rxq_elt (*elts)[rxq->elts_n] = rxq->elts;
 316         unsigned int i;
 317
 318         /* For each WR (packet). */
 319         for (i = 0; i != RTE_DIM(*elts); ++i) {
 320                 struct rxq_elt *elt = &(*elts)[i];
 321                 struct ibv_recv_wr *wr = &elt->wr;
 322                 struct ibv_sge *sge = &(*elts)[i].sge;
 323                 struct rte_mbuf *buf = rte_pktmbuf_alloc(rxq->mp);
 324
 325                 if (buf == NULL) {
 326                         while (i--) {
 327                                 rte_pktmbuf_free_seg((*elts)[i].buf);
 328                                 (*elts)[i].buf = NULL;
 329                         }
 330                         rte_errno = ENOMEM;
 331                         return -rte_errno;
 332                 }
 333                 elt->buf = buf;
 334                 wr->next = &(*elts)[(i + 1)].wr;
 335                 wr->sg_list = sge;
 336                 wr->num_sge = 1;
 337                 /* Headroom is reserved by rte_pktmbuf_alloc(). */
 338                 assert(buf->data_off == RTE_PKTMBUF_HEADROOM);
 339                 /* Buffer is supposed to be empty. */
 340                 assert(rte_pktmbuf_data_len(buf) == 0);
 341                 assert(rte_pktmbuf_pkt_len(buf) == 0);
 342                 /* sge->addr must be able to store a pointer. */
 343                 assert(sizeof(sge->addr) >= sizeof(uintptr_t));
 344                 /* SGE keeps its headroom. */
 345                 sge->addr = (uintptr_t)
 346                         ((uint8_t *)buf->buf_addr + RTE_PKTMBUF_HEADROOM);
 347                 sge->length = (buf->buf_len - RTE_PKTMBUF_HEADROOM);
 348                 sge->lkey = rxq->mr->lkey;
 349                 /* Redundant check for tailroom. */
 350                 assert(sge->length == rte_pktmbuf_tailroom(buf));
 351         }
 352         /* The last WR pointer must be NULL. */
 353         (*elts)[(i - 1)].wr.next = NULL;
 354         return 0;
 355 }
 356
 357 /**
 358  * Free Rx queue elements.
 359  *
 360  * @param rxq
 361  *   Pointer to Rx queue structure.
 362  */
 363 static void
 364 mlx4_rxq_free_elts(struct rxq *rxq)
 365 {
 366         unsigned int i;
 367         struct rxq_elt (*elts)[rxq->elts_n] = rxq->elts;
 368
 369         DEBUG("%p: freeing WRs", (void *)rxq);
 370         for (i = 0; (i != RTE_DIM(*elts)); ++i) {
 371                 if (!(*elts)[i].buf)
 372                         continue;
 373                 rte_pktmbuf_free_seg((*elts)[i].buf);
 374                 (*elts)[i].buf = NULL;
 375         }
 376 }
 377
 378 /**
 379  * DPDK callback to configure a Rx queue.
 380  *
 381  * @param dev
 382  *   Pointer to Ethernet device structure.
 383  * @param idx
 384  *   Rx queue index.
 385  * @param desc
 386  *   Number of descriptors to configure in queue.
 387  * @param socket
 388  *   NUMA socket on which memory must be allocated.
 389  * @param[in] conf
 390  *   Thresholds parameters.
 391  * @param mp
 392  *   Memory pool for buffer allocations.
 393  *
 394  * @return
 395  *   0 on success, negative errno value otherwise and rte_errno is set.
 396  */
 397 int
 398 mlx4_rx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t desc,
 399                     unsigned int socket, const struct rte_eth_rxconf *conf,
 400                     struct rte_mempool *mp)
 401 {
 402         struct priv *priv = dev->data->dev_private;
 403         uint32_t mb_len = rte_pktmbuf_data_room_size(mp);
 404         struct rxq_elt (*elts)[desc];
 405         struct rte_flow_error error;
 406         struct rxq *rxq;
 407         struct mlx4_malloc_vec vec[] = {
 408                 {
 409                         .align = RTE_CACHE_LINE_SIZE,
 410                         .size = sizeof(*rxq),
 411                         .addr = (void **)&rxq,
 412                 },
 413                 {
 414                         .align = RTE_CACHE_LINE_SIZE,
 415                         .size = sizeof(*elts),
 416                         .addr = (void **)&elts,
 417                 },
 418         };
 419         int ret;
 420
 421         (void)conf; /* Thresholds configuration (ignored). */
 422         DEBUG("%p: configuring queue %u for %u descriptors",
 423               (void *)dev, idx, desc);
 424         if (idx >= dev->data->nb_rx_queues) {
 425                 rte_errno = EOVERFLOW;
 426                 ERROR("%p: queue index out of range (%u >= %u)",
 427                       (void *)dev, idx, dev->data->nb_rx_queues);
 428                 return -rte_errno;
 429         }
 430         rxq = dev->data->rx_queues[idx];
 431         if (rxq) {
 432                 rte_errno = EEXIST;
 433                 ERROR("%p: Rx queue %u already configured, release it first",
 434                       (void *)dev, idx);
 435                 return -rte_errno;
 436         }
 437         if (!desc) {
 438                 rte_errno = EINVAL;
 439                 ERROR("%p: invalid number of Rx descriptors", (void *)dev);
 440                 return -rte_errno;
 441         }
 442         /* Allocate and initialize Rx queue. */
 443         mlx4_zmallocv_socket("RXQ", vec, RTE_DIM(vec), socket);
 444         if (!rxq) {
 445                 ERROR("%p: unable to allocate queue index %u",
 446                       (void *)dev, idx);
 447                 return -rte_errno;
 448         }
 449         *rxq = (struct rxq){
 450                 .priv = priv,
 451                 .mp = mp,
 452                 .port_id = dev->data->port_id,
 453                 .elts_n = desc,
 454                 .elts_head = 0,
 455                 .elts = elts,
 456                 .stats.idx = idx,
 457                 .socket = socket,
 458         };
 459         /* Enable scattered packets support for this queue if necessary. */
 460         assert(mb_len >= RTE_PKTMBUF_HEADROOM);
 461         if (dev->data->dev_conf.rxmode.max_rx_pkt_len <=
 462             (mb_len - RTE_PKTMBUF_HEADROOM)) {
 463                 ;
 464         } else if (dev->data->dev_conf.rxmode.enable_scatter) {
 465                 WARN("%p: scattered mode has been requested but is"
 466                      " not supported, this may lead to packet loss",
 467                      (void *)dev);
 468         } else {
 469                 WARN("%p: the requested maximum Rx packet size (%u) is"
 470                      " larger than a single mbuf (%u) and scattered"
 471                      " mode has not been requested",
 472                      (void *)dev,
 473                      dev->data->dev_conf.rxmode.max_rx_pkt_len,
 474                      mb_len - RTE_PKTMBUF_HEADROOM);
 475         }
 476         /* Use the entire Rx mempool as the memory region. */
 477         rxq->mr = mlx4_mp2mr(priv->pd, mp);
 478         if (!rxq->mr) {
 479                 rte_errno = EINVAL;
 480                 ERROR("%p: MR creation failure: %s",
 481                       (void *)dev, strerror(rte_errno));
 482                 goto error;
 483         }
 484         if (dev->data->dev_conf.intr_conf.rxq) {
 485                 rxq->channel = ibv_create_comp_channel(priv->ctx);
 486                 if (rxq->channel == NULL) {
 487                         rte_errno = ENOMEM;
 488                         ERROR("%p: Rx interrupt completion channel creation"
 489                               " failure: %s",
 490                               (void *)dev, strerror(rte_errno));
 491                         goto error;
 492                 }
 493                 if (mlx4_fd_set_non_blocking(rxq->channel->fd) < 0) {
 494                         ERROR("%p: unable to make Rx interrupt completion"
 495                               " channel non-blocking: %s",
 496                               (void *)dev, strerror(rte_errno));
 497                         goto error;
 498                 }
 499         }
 500         rxq->cq = ibv_create_cq(priv->ctx, desc, NULL, rxq->channel, 0);
 501         if (!rxq->cq) {
 502                 rte_errno = ENOMEM;
 503                 ERROR("%p: CQ creation failure: %s",
 504                       (void *)dev, strerror(rte_errno));
 505                 goto error;
 506         }
 507         rxq->wq = ibv_create_wq
 508                 (priv->ctx,
 509                  &(struct ibv_wq_init_attr){
 510                         .wq_type = IBV_WQT_RQ,
 511                         .max_wr = RTE_MIN(priv->device_attr.max_qp_wr, desc),
 512                         .max_sge = 1,
 513                         .pd = priv->pd,
 514                         .cq = rxq->cq,
 515                  });
 516         if (!rxq->wq) {
 517                 rte_errno = errno ? errno : EINVAL;
 518                 ERROR("%p: WQ creation failure: %s",
 519                       (void *)dev, strerror(rte_errno));
 520                 goto error;
 521         }
 522         ret = ibv_modify_wq
 523                 (rxq->wq,
 524                  &(struct ibv_wq_attr){
 525                         .attr_mask = IBV_WQ_ATTR_STATE,
 526                         .wq_state = IBV_WQS_RDY,
 527                  });
 528         if (ret) {
 529                 rte_errno = ret;
 530                 ERROR("%p: WQ state to IBV_WPS_RDY failed: %s",
 531                       (void *)dev, strerror(rte_errno));
 532                 goto error;
 533         }
 534         ret = mlx4_rxq_alloc_elts(rxq);
 535         if (ret) {
 536                 ERROR("%p: RXQ allocation failed: %s",
 537                       (void *)dev, strerror(rte_errno));
 538                 goto error;
 539         }
 540         ret = ibv_post_wq_recv(rxq->wq, &(*rxq->elts)[0].wr,
 541                                &(struct ibv_recv_wr *){ NULL });
 542         if (ret) {
 543                 rte_errno = ret;
 544                 ERROR("%p: ibv_post_recv() failed: %s",
 545                       (void *)dev,
 546                       strerror(rte_errno));
 547                 goto error;
 548         }
 549         DEBUG("%p: adding Rx queue %p to list", (void *)dev, (void *)rxq);
 550         dev->data->rx_queues[idx] = rxq;
 551         /* Enable associated flows. */
 552         ret = mlx4_flow_sync(priv, &error);
 553         if (!ret)
 554                 return 0;
 555         ERROR("cannot re-attach flow rules to queue %u"
 556               " (code %d, \"%s\"), flow error type %d, cause %p, message: %s",
 557               idx, -ret, strerror(-ret), error.type, error.cause,
 558               error.message ? error.message : "(unspecified)");
 559 error:
 560         dev->data->rx_queues[idx] = NULL;
 561         ret = rte_errno;
 562         mlx4_rx_queue_release(rxq);
 563         rte_errno = ret;
 564         assert(rte_errno > 0);
 565         return -rte_errno;
 566 }
 567
 568 /**
 569  * DPDK callback to release a Rx queue.
 570  *
 571  * @param dpdk_rxq
 572  *   Generic Rx queue pointer.
 573  */
 574 void
 575 mlx4_rx_queue_release(void *dpdk_rxq)
 576 {
 577         struct rxq *rxq = (struct rxq *)dpdk_rxq;
 578         struct priv *priv;
 579         unsigned int i;
 580
 581         if (rxq == NULL)
 582                 return;
 583         priv = rxq->priv;
 584         for (i = 0; i != priv->dev->data->nb_rx_queues; ++i)
 585                 if (priv->dev->data->rx_queues[i] == rxq) {
 586                         DEBUG("%p: removing Rx queue %p from list",
 587                               (void *)priv->dev, (void *)rxq);
 588                         priv->dev->data->rx_queues[i] = NULL;
 589                         break;
 590                 }
 591         mlx4_flow_sync(priv, NULL);
 592         mlx4_rxq_free_elts(rxq);
 593         if (rxq->wq)
 594                 claim_zero(ibv_destroy_wq(rxq->wq));
 595         if (rxq->cq)
 596                 claim_zero(ibv_destroy_cq(rxq->cq));
 597         if (rxq->channel)
 598                 claim_zero(ibv_destroy_comp_channel(rxq->channel));
 599         if (rxq->mr)
 600                 claim_zero(ibv_dereg_mr(rxq->mr));
 601         rte_free(rxq);
 602 }