Imported Upstream version 16.11.1
[deb_dpdk.git] / drivers / net / mlx5 / mlx5_txq.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright 2015 6WIND S.A.
5  *   Copyright 2015 Mellanox.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of 6WIND S.A. nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include <stddef.h>
35 #include <assert.h>
36 #include <errno.h>
37 #include <string.h>
38 #include <stdint.h>
39
40 /* Verbs header. */
41 /* ISO C doesn't support unnamed structs/unions, disabling -pedantic. */
42 #ifdef PEDANTIC
43 #pragma GCC diagnostic ignored "-Wpedantic"
44 #endif
45 #include <infiniband/verbs.h>
46 #ifdef PEDANTIC
47 #pragma GCC diagnostic error "-Wpedantic"
48 #endif
49
50 /* DPDK headers don't like -pedantic. */
51 #ifdef PEDANTIC
52 #pragma GCC diagnostic ignored "-Wpedantic"
53 #endif
54 #include <rte_mbuf.h>
55 #include <rte_malloc.h>
56 #include <rte_ethdev.h>
57 #include <rte_common.h>
58 #ifdef PEDANTIC
59 #pragma GCC diagnostic error "-Wpedantic"
60 #endif
61
62 #include "mlx5_utils.h"
63 #include "mlx5_defs.h"
64 #include "mlx5.h"
65 #include "mlx5_rxtx.h"
66 #include "mlx5_autoconf.h"
67 #include "mlx5_defs.h"
68
69 /**
70  * Allocate TX queue elements.
71  *
72  * @param txq_ctrl
73  *   Pointer to TX queue structure.
74  * @param elts_n
75  *   Number of elements to allocate.
76  */
77 static void
78 txq_alloc_elts(struct txq_ctrl *txq_ctrl, unsigned int elts_n)
79 {
80         unsigned int i;
81
82         for (i = 0; (i != elts_n); ++i)
83                 (*txq_ctrl->txq.elts)[i] = NULL;
84         for (i = 0; (i != (1u << txq_ctrl->txq.wqe_n)); ++i) {
85                 volatile struct mlx5_wqe64 *wqe = &(*txq_ctrl->txq.wqes)[i];
86
87                 memset((void *)(uintptr_t)wqe, 0x0, sizeof(*wqe));
88         }
89         DEBUG("%p: allocated and configured %u WRs", (void *)txq_ctrl, elts_n);
90         txq_ctrl->txq.elts_head = 0;
91         txq_ctrl->txq.elts_tail = 0;
92         txq_ctrl->txq.elts_comp = 0;
93 }
94
95 /**
96  * Free TX queue elements.
97  *
98  * @param txq_ctrl
99  *   Pointer to TX queue structure.
100  */
101 static void
102 txq_free_elts(struct txq_ctrl *txq_ctrl)
103 {
104         unsigned int elts_n = 1 << txq_ctrl->txq.elts_n;
105         unsigned int elts_head = txq_ctrl->txq.elts_head;
106         unsigned int elts_tail = txq_ctrl->txq.elts_tail;
107         struct rte_mbuf *(*elts)[elts_n] = txq_ctrl->txq.elts;
108
109         DEBUG("%p: freeing WRs", (void *)txq_ctrl);
110         txq_ctrl->txq.elts_head = 0;
111         txq_ctrl->txq.elts_tail = 0;
112         txq_ctrl->txq.elts_comp = 0;
113
114         while (elts_tail != elts_head) {
115                 struct rte_mbuf *elt = (*elts)[elts_tail];
116
117                 assert(elt != NULL);
118                 rte_pktmbuf_free(elt);
119 #ifndef NDEBUG
120                 /* Poisoning. */
121                 memset(&(*elts)[elts_tail],
122                        0x77,
123                        sizeof((*elts)[elts_tail]));
124 #endif
125                 if (++elts_tail == elts_n)
126                         elts_tail = 0;
127         }
128 }
129
130 /**
131  * Clean up a TX queue.
132  *
133  * Destroy objects, free allocated memory and reset the structure for reuse.
134  *
135  * @param txq_ctrl
136  *   Pointer to TX queue structure.
137  */
138 void
139 txq_cleanup(struct txq_ctrl *txq_ctrl)
140 {
141         struct ibv_exp_release_intf_params params;
142         size_t i;
143
144         DEBUG("cleaning up %p", (void *)txq_ctrl);
145         txq_free_elts(txq_ctrl);
146         if (txq_ctrl->if_qp != NULL) {
147                 assert(txq_ctrl->priv != NULL);
148                 assert(txq_ctrl->priv->ctx != NULL);
149                 assert(txq_ctrl->qp != NULL);
150                 params = (struct ibv_exp_release_intf_params){
151                         .comp_mask = 0,
152                 };
153                 claim_zero(ibv_exp_release_intf(txq_ctrl->priv->ctx,
154                                                 txq_ctrl->if_qp,
155                                                 &params));
156         }
157         if (txq_ctrl->if_cq != NULL) {
158                 assert(txq_ctrl->priv != NULL);
159                 assert(txq_ctrl->priv->ctx != NULL);
160                 assert(txq_ctrl->cq != NULL);
161                 params = (struct ibv_exp_release_intf_params){
162                         .comp_mask = 0,
163                 };
164                 claim_zero(ibv_exp_release_intf(txq_ctrl->priv->ctx,
165                                                 txq_ctrl->if_cq,
166                                                 &params));
167         }
168         if (txq_ctrl->qp != NULL)
169                 claim_zero(ibv_destroy_qp(txq_ctrl->qp));
170         if (txq_ctrl->cq != NULL)
171                 claim_zero(ibv_destroy_cq(txq_ctrl->cq));
172         if (txq_ctrl->rd != NULL) {
173                 struct ibv_exp_destroy_res_domain_attr attr = {
174                         .comp_mask = 0,
175                 };
176
177                 assert(txq_ctrl->priv != NULL);
178                 assert(txq_ctrl->priv->ctx != NULL);
179                 claim_zero(ibv_exp_destroy_res_domain(txq_ctrl->priv->ctx,
180                                                       txq_ctrl->rd,
181                                                       &attr));
182         }
183         for (i = 0; (i != RTE_DIM(txq_ctrl->txq.mp2mr)); ++i) {
184                 if (txq_ctrl->txq.mp2mr[i].mp == NULL)
185                         break;
186                 assert(txq_ctrl->txq.mp2mr[i].mr != NULL);
187                 claim_zero(ibv_dereg_mr(txq_ctrl->txq.mp2mr[i].mr));
188         }
189         memset(txq_ctrl, 0, sizeof(*txq_ctrl));
190 }
191
192 /**
193  * Initialize TX queue.
194  *
195  * @param tmpl
196  *   Pointer to TX queue control template.
197  * @param txq_ctrl
198  *   Pointer to TX queue control.
199  *
200  * @return
201  *   0 on success, errno value on failure.
202  */
203 static inline int
204 txq_setup(struct txq_ctrl *tmpl, struct txq_ctrl *txq_ctrl)
205 {
206         struct mlx5_qp *qp = to_mqp(tmpl->qp);
207         struct ibv_cq *ibcq = tmpl->cq;
208         struct mlx5_cq *cq = to_mxxx(cq, cq);
209
210         if (cq->cqe_sz != RTE_CACHE_LINE_SIZE) {
211                 ERROR("Wrong MLX5_CQE_SIZE environment variable value: "
212                       "it should be set to %u", RTE_CACHE_LINE_SIZE);
213                 return EINVAL;
214         }
215         tmpl->txq.cqe_n = log2above(ibcq->cqe);
216         tmpl->txq.qp_num_8s = qp->ctrl_seg.qp_num << 8;
217         tmpl->txq.wqes =
218                 (volatile struct mlx5_wqe64 (*)[])
219                 (uintptr_t)qp->gen_data.sqstart;
220         tmpl->txq.wqe_n = log2above(qp->sq.wqe_cnt);
221         tmpl->txq.qp_db = &qp->gen_data.db[MLX5_SND_DBR];
222         tmpl->txq.bf_reg = qp->gen_data.bf->reg;
223         tmpl->txq.cq_db = cq->dbrec;
224         tmpl->txq.cqes =
225                 (volatile struct mlx5_cqe (*)[])
226                 (uintptr_t)cq->active_buf->buf;
227         tmpl->txq.elts =
228                 (struct rte_mbuf *(*)[1 << tmpl->txq.elts_n])
229                 ((uintptr_t)txq_ctrl + sizeof(*txq_ctrl));
230         return 0;
231 }
232
233 /**
234  * Configure a TX queue.
235  *
236  * @param dev
237  *   Pointer to Ethernet device structure.
238  * @param txq_ctrl
239  *   Pointer to TX queue structure.
240  * @param desc
241  *   Number of descriptors to configure in queue.
242  * @param socket
243  *   NUMA socket on which memory must be allocated.
244  * @param[in] conf
245  *   Thresholds parameters.
246  *
247  * @return
248  *   0 on success, errno value on failure.
249  */
250 int
251 txq_ctrl_setup(struct rte_eth_dev *dev, struct txq_ctrl *txq_ctrl,
252                uint16_t desc, unsigned int socket,
253                const struct rte_eth_txconf *conf)
254 {
255         struct priv *priv = mlx5_get_priv(dev);
256         struct txq_ctrl tmpl = {
257                 .priv = priv,
258                 .socket = socket,
259         };
260         union {
261                 struct ibv_exp_query_intf_params params;
262                 struct ibv_exp_qp_init_attr init;
263                 struct ibv_exp_res_domain_init_attr rd;
264                 struct ibv_exp_cq_init_attr cq;
265                 struct ibv_exp_qp_attr mod;
266                 struct ibv_exp_cq_attr cq_attr;
267         } attr;
268         enum ibv_exp_query_intf_status status;
269         int ret = 0;
270
271         if (mlx5_getenv_int("MLX5_ENABLE_CQE_COMPRESSION")) {
272                 ret = ENOTSUP;
273                 ERROR("MLX5_ENABLE_CQE_COMPRESSION must never be set");
274                 goto error;
275         }
276         (void)conf; /* Thresholds configuration (ignored). */
277         assert(desc > MLX5_TX_COMP_THRESH);
278         tmpl.txq.elts_n = log2above(desc);
279         /* MRs will be registered in mp2mr[] later. */
280         attr.rd = (struct ibv_exp_res_domain_init_attr){
281                 .comp_mask = (IBV_EXP_RES_DOMAIN_THREAD_MODEL |
282                               IBV_EXP_RES_DOMAIN_MSG_MODEL),
283                 .thread_model = IBV_EXP_THREAD_SINGLE,
284                 .msg_model = IBV_EXP_MSG_HIGH_BW,
285         };
286         tmpl.rd = ibv_exp_create_res_domain(priv->ctx, &attr.rd);
287         if (tmpl.rd == NULL) {
288                 ret = ENOMEM;
289                 ERROR("%p: RD creation failure: %s",
290                       (void *)dev, strerror(ret));
291                 goto error;
292         }
293         attr.cq = (struct ibv_exp_cq_init_attr){
294                 .comp_mask = IBV_EXP_CQ_INIT_ATTR_RES_DOMAIN,
295                 .res_domain = tmpl.rd,
296         };
297         tmpl.cq = ibv_exp_create_cq(priv->ctx,
298                                     (((desc / MLX5_TX_COMP_THRESH) - 1) ?
299                                      ((desc / MLX5_TX_COMP_THRESH) - 1) : 1),
300                                     NULL, NULL, 0, &attr.cq);
301         if (tmpl.cq == NULL) {
302                 ret = ENOMEM;
303                 ERROR("%p: CQ creation failure: %s",
304                       (void *)dev, strerror(ret));
305                 goto error;
306         }
307         DEBUG("priv->device_attr.max_qp_wr is %d",
308               priv->device_attr.max_qp_wr);
309         DEBUG("priv->device_attr.max_sge is %d",
310               priv->device_attr.max_sge);
311         attr.init = (struct ibv_exp_qp_init_attr){
312                 /* CQ to be associated with the send queue. */
313                 .send_cq = tmpl.cq,
314                 /* CQ to be associated with the receive queue. */
315                 .recv_cq = tmpl.cq,
316                 .cap = {
317                         /* Max number of outstanding WRs. */
318                         .max_send_wr = ((priv->device_attr.max_qp_wr < desc) ?
319                                         priv->device_attr.max_qp_wr :
320                                         desc),
321                         /*
322                          * Max number of scatter/gather elements in a WR,
323                          * must be 1 to prevent libmlx5 from trying to affect
324                          * too much memory. TX gather is not impacted by the
325                          * priv->device_attr.max_sge limit and will still work
326                          * properly.
327                          */
328                         .max_send_sge = 1,
329                 },
330                 .qp_type = IBV_QPT_RAW_PACKET,
331                 /* Do *NOT* enable this, completions events are managed per
332                  * TX burst. */
333                 .sq_sig_all = 0,
334                 .pd = priv->pd,
335                 .res_domain = tmpl.rd,
336                 .comp_mask = (IBV_EXP_QP_INIT_ATTR_PD |
337                               IBV_EXP_QP_INIT_ATTR_RES_DOMAIN),
338         };
339         if (priv->txq_inline && (priv->txqs_n >= priv->txqs_inline)) {
340                 tmpl.txq.max_inline =
341                         ((priv->txq_inline + (RTE_CACHE_LINE_SIZE - 1)) /
342                          RTE_CACHE_LINE_SIZE);
343                 attr.init.cap.max_inline_data =
344                         tmpl.txq.max_inline * RTE_CACHE_LINE_SIZE;
345         }
346         tmpl.qp = ibv_exp_create_qp(priv->ctx, &attr.init);
347         if (tmpl.qp == NULL) {
348                 ret = (errno ? errno : EINVAL);
349                 ERROR("%p: QP creation failure: %s",
350                       (void *)dev, strerror(ret));
351                 goto error;
352         }
353         DEBUG("TX queue capabilities: max_send_wr=%u, max_send_sge=%u,"
354               " max_inline_data=%u",
355               attr.init.cap.max_send_wr,
356               attr.init.cap.max_send_sge,
357               attr.init.cap.max_inline_data);
358         attr.mod = (struct ibv_exp_qp_attr){
359                 /* Move the QP to this state. */
360                 .qp_state = IBV_QPS_INIT,
361                 /* Primary port number. */
362                 .port_num = priv->port
363         };
364         ret = ibv_exp_modify_qp(tmpl.qp, &attr.mod,
365                                 (IBV_EXP_QP_STATE | IBV_EXP_QP_PORT));
366         if (ret) {
367                 ERROR("%p: QP state to IBV_QPS_INIT failed: %s",
368                       (void *)dev, strerror(ret));
369                 goto error;
370         }
371         ret = txq_setup(&tmpl, txq_ctrl);
372         if (ret) {
373                 ERROR("%p: cannot initialize TX queue structure: %s",
374                       (void *)dev, strerror(ret));
375                 goto error;
376         }
377         txq_alloc_elts(&tmpl, desc);
378         attr.mod = (struct ibv_exp_qp_attr){
379                 .qp_state = IBV_QPS_RTR
380         };
381         ret = ibv_exp_modify_qp(tmpl.qp, &attr.mod, IBV_EXP_QP_STATE);
382         if (ret) {
383                 ERROR("%p: QP state to IBV_QPS_RTR failed: %s",
384                       (void *)dev, strerror(ret));
385                 goto error;
386         }
387         attr.mod.qp_state = IBV_QPS_RTS;
388         ret = ibv_exp_modify_qp(tmpl.qp, &attr.mod, IBV_EXP_QP_STATE);
389         if (ret) {
390                 ERROR("%p: QP state to IBV_QPS_RTS failed: %s",
391                       (void *)dev, strerror(ret));
392                 goto error;
393         }
394         attr.params = (struct ibv_exp_query_intf_params){
395                 .intf_scope = IBV_EXP_INTF_GLOBAL,
396                 .intf = IBV_EXP_INTF_CQ,
397                 .obj = tmpl.cq,
398         };
399         tmpl.if_cq = ibv_exp_query_intf(priv->ctx, &attr.params, &status);
400         if (tmpl.if_cq == NULL) {
401                 ret = EINVAL;
402                 ERROR("%p: CQ interface family query failed with status %d",
403                       (void *)dev, status);
404                 goto error;
405         }
406         attr.params = (struct ibv_exp_query_intf_params){
407                 .intf_scope = IBV_EXP_INTF_GLOBAL,
408                 .intf = IBV_EXP_INTF_QP_BURST,
409                 .intf_version = 1,
410                 .obj = tmpl.qp,
411                 /* Enable multi-packet send if supported. */
412                 .family_flags =
413                         ((priv->mps && !priv->sriov) ?
414                          IBV_EXP_QP_BURST_CREATE_ENABLE_MULTI_PACKET_SEND_WR :
415                          0),
416         };
417         tmpl.if_qp = ibv_exp_query_intf(priv->ctx, &attr.params, &status);
418         if (tmpl.if_qp == NULL) {
419                 ret = EINVAL;
420                 ERROR("%p: QP interface family query failed with status %d",
421                       (void *)dev, status);
422                 goto error;
423         }
424         /* Clean up txq in case we're reinitializing it. */
425         DEBUG("%p: cleaning-up old txq just in case", (void *)txq_ctrl);
426         txq_cleanup(txq_ctrl);
427         *txq_ctrl = tmpl;
428         DEBUG("%p: txq updated with %p", (void *)txq_ctrl, (void *)&tmpl);
429         /* Pre-register known mempools. */
430         rte_mempool_walk(txq_mp2mr_iter, txq_ctrl);
431         assert(ret == 0);
432         return 0;
433 error:
434         txq_cleanup(&tmpl);
435         assert(ret > 0);
436         return ret;
437 }
438
439 /**
440  * DPDK callback to configure a TX queue.
441  *
442  * @param dev
443  *   Pointer to Ethernet device structure.
444  * @param idx
445  *   TX queue index.
446  * @param desc
447  *   Number of descriptors to configure in queue.
448  * @param socket
449  *   NUMA socket on which memory must be allocated.
450  * @param[in] conf
451  *   Thresholds parameters.
452  *
453  * @return
454  *   0 on success, negative errno value on failure.
455  */
456 int
457 mlx5_tx_queue_setup(struct rte_eth_dev *dev, uint16_t idx, uint16_t desc,
458                     unsigned int socket, const struct rte_eth_txconf *conf)
459 {
460         struct priv *priv = dev->data->dev_private;
461         struct txq *txq = (*priv->txqs)[idx];
462         struct txq_ctrl *txq_ctrl = container_of(txq, struct txq_ctrl, txq);
463         int ret;
464
465         if (mlx5_is_secondary())
466                 return -E_RTE_SECONDARY;
467
468         priv_lock(priv);
469         if (desc <= MLX5_TX_COMP_THRESH) {
470                 WARN("%p: number of descriptors requested for TX queue %u"
471                      " must be higher than MLX5_TX_COMP_THRESH, using"
472                      " %u instead of %u",
473                      (void *)dev, idx, MLX5_TX_COMP_THRESH + 1, desc);
474                 desc = MLX5_TX_COMP_THRESH + 1;
475         }
476         if (!rte_is_power_of_2(desc)) {
477                 desc = 1 << log2above(desc);
478                 WARN("%p: increased number of descriptors in TX queue %u"
479                      " to the next power of two (%d)",
480                      (void *)dev, idx, desc);
481         }
482         DEBUG("%p: configuring queue %u for %u descriptors",
483               (void *)dev, idx, desc);
484         if (idx >= priv->txqs_n) {
485                 ERROR("%p: queue index out of range (%u >= %u)",
486                       (void *)dev, idx, priv->txqs_n);
487                 priv_unlock(priv);
488                 return -EOVERFLOW;
489         }
490         if (txq != NULL) {
491                 DEBUG("%p: reusing already allocated queue index %u (%p)",
492                       (void *)dev, idx, (void *)txq);
493                 if (priv->started) {
494                         priv_unlock(priv);
495                         return -EEXIST;
496                 }
497                 (*priv->txqs)[idx] = NULL;
498                 txq_cleanup(txq_ctrl);
499         } else {
500                 txq_ctrl =
501                         rte_calloc_socket("TXQ", 1,
502                                           sizeof(*txq_ctrl) +
503                                           desc * sizeof(struct rte_mbuf *),
504                                           0, socket);
505                 if (txq_ctrl == NULL) {
506                         ERROR("%p: unable to allocate queue index %u",
507                               (void *)dev, idx);
508                         priv_unlock(priv);
509                         return -ENOMEM;
510                 }
511         }
512         ret = txq_ctrl_setup(dev, txq_ctrl, desc, socket, conf);
513         if (ret)
514                 rte_free(txq_ctrl);
515         else {
516                 txq_ctrl->txq.stats.idx = idx;
517                 DEBUG("%p: adding TX queue %p to list",
518                       (void *)dev, (void *)txq_ctrl);
519                 (*priv->txqs)[idx] = &txq_ctrl->txq;
520                 /* Update send callback. */
521                 priv_select_tx_function(priv);
522         }
523         priv_unlock(priv);
524         return -ret;
525 }
526
527 /**
528  * DPDK callback to release a TX queue.
529  *
530  * @param dpdk_txq
531  *   Generic TX queue pointer.
532  */
533 void
534 mlx5_tx_queue_release(void *dpdk_txq)
535 {
536         struct txq *txq = (struct txq *)dpdk_txq;
537         struct txq_ctrl *txq_ctrl;
538         struct priv *priv;
539         unsigned int i;
540
541         if (mlx5_is_secondary())
542                 return;
543
544         if (txq == NULL)
545                 return;
546         txq_ctrl = container_of(txq, struct txq_ctrl, txq);
547         priv = txq_ctrl->priv;
548         priv_lock(priv);
549         for (i = 0; (i != priv->txqs_n); ++i)
550                 if ((*priv->txqs)[i] == txq) {
551                         DEBUG("%p: removing TX queue %p from list",
552                               (void *)priv->dev, (void *)txq_ctrl);
553                         (*priv->txqs)[i] = NULL;
554                         break;
555                 }
556         txq_cleanup(txq_ctrl);
557         rte_free(txq_ctrl);
558         priv_unlock(priv);
559 }
560
561 /**
562  * DPDK callback for TX in secondary processes.
563  *
564  * This function configures all queues from primary process information
565  * if necessary before reverting to the normal TX burst callback.
566  *
567  * @param dpdk_txq
568  *   Generic pointer to TX queue structure.
569  * @param[in] pkts
570  *   Packets to transmit.
571  * @param pkts_n
572  *   Number of packets in array.
573  *
574  * @return
575  *   Number of packets successfully transmitted (<= pkts_n).
576  */
577 uint16_t
578 mlx5_tx_burst_secondary_setup(void *dpdk_txq, struct rte_mbuf **pkts,
579                               uint16_t pkts_n)
580 {
581         struct txq *txq = dpdk_txq;
582         struct txq_ctrl *txq_ctrl = container_of(txq, struct txq_ctrl, txq);
583         struct priv *priv = mlx5_secondary_data_setup(txq_ctrl->priv);
584         struct priv *primary_priv;
585         unsigned int index;
586
587         if (priv == NULL)
588                 return 0;
589         primary_priv =
590                 mlx5_secondary_data[priv->dev->data->port_id].primary_priv;
591         /* Look for queue index in both private structures. */
592         for (index = 0; index != priv->txqs_n; ++index)
593                 if (((*primary_priv->txqs)[index] == txq) ||
594                     ((*priv->txqs)[index] == txq))
595                         break;
596         if (index == priv->txqs_n)
597                 return 0;
598         txq = (*priv->txqs)[index];
599         return priv->dev->tx_pkt_burst(txq, pkts, pkts_n);
600 }