fix various typos found by Lintian

[dpdk.git] / drivers / net / mlx5 / mlx5_rxtx.c

diff --git a/drivers/net/mlx5/mlx5_rxtx.c b/drivers/net/mlx5/mlx5_rxtx.c
index 4c27952..a212010 100644 (file)
--- a/drivers/net/mlx5/mlx5_rxtx.c
+++ b/drivers/net/mlx5/mlx5_rxtx.c
@@ -33,6 +33,7 @@
 
 #include "mlx5_defs.h"
 #include "mlx5.h"
+#include "mlx5_mr.h"
 #include "mlx5_utils.h"
 #include "mlx5_rxtx.h"
 #include "mlx5_autoconf.h"
@@ -1000,6 +1001,7 @@ static int
 mlx5_queue_state_modify(struct rte_eth_dev *dev,
                        struct mlx5_mp_arg_queue_state_modify *sm)
 {
+       struct mlx5_priv *priv = dev->data->dev_private;
        int ret = 0;
 
        switch (rte_eal_process_type()) {
@@ -1007,7 +1009,7 @@ mlx5_queue_state_modify(struct rte_eth_dev *dev,
                ret = mlx5_queue_state_modify_primary(dev, sm);
                break;
        case RTE_PROC_SECONDARY:
-               ret = mlx5_mp_req_queue_state_modify(dev, sm);
+               ret = mlx5_mp_req_queue_state_modify(&priv->mp_id, sm);
                break;
        default:
                break;
@@ -1337,9 +1339,10 @@ rxq_cq_to_mbuf(struct mlx5_rxq_data *rxq, struct rte_mbuf *pkt,
                        pkt->hash.fdir.hi = mlx5_flow_mark_get(mark);
                }
        }
-       if (rte_flow_dynf_metadata_avail() && cqe->flow_table_metadata) {
-               pkt->ol_flags |= PKT_RX_DYNF_METADATA;
-               *RTE_FLOW_DYNF_METADATA(pkt) = cqe->flow_table_metadata;
+       if (rxq->dynf_meta && cqe->flow_table_metadata) {
+               pkt->ol_flags |= rxq->flow_meta_mask;
+               *RTE_MBUF_DYNFIELD(pkt, rxq->flow_meta_offset, uint32_t *) =
+                       cqe->flow_table_metadata;
        }
        if (rxq->csum)
                pkt->ol_flags |= rxq_cq_to_ol_flags(cqe);
@@ -1734,22 +1737,52 @@ mlx5_rx_burst_mprq(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
                 * Memcpy packets to the target mbuf if:
                 * - The size of packet is smaller than mprq_max_memcpy_len.
                 * - Out of buffer in the Mempool for Multi-Packet RQ.
-                * - There is no space for a headroom and scatter is disabled.
+                * - The packet's stride overlaps a headroom and scatter is off.
                 */
                if (len <= rxq->mprq_max_memcpy_len ||
                    rxq->mprq_repl == NULL ||
                    (hdrm_overlap > 0 && !rxq->strd_scatter_en)) {
-                       /*
-                        * When memcpy'ing packet due to out-of-buffer, the
-                        * packet must be smaller than the target mbuf.
-                        */
-                       if (unlikely(rte_pktmbuf_tailroom(pkt) < len)) {
+                       if (likely(rte_pktmbuf_tailroom(pkt) >= len)) {
+                               rte_memcpy(rte_pktmbuf_mtod(pkt, void *),
+                                          addr, len);
+                               DATA_LEN(pkt) = len;
+                       } else if (rxq->strd_scatter_en) {
+                               struct rte_mbuf *prev = pkt;
+                               uint32_t seg_len =
+                                       RTE_MIN(rte_pktmbuf_tailroom(pkt), len);
+                               uint32_t rem_len = len - seg_len;
+
+                               rte_memcpy(rte_pktmbuf_mtod(pkt, void *),
+                                          addr, seg_len);
+                               DATA_LEN(pkt) = seg_len;
+                               while (rem_len) {
+                                       struct rte_mbuf *next =
+                                               rte_pktmbuf_alloc(rxq->mp);
+
+                                       if (unlikely(next == NULL)) {
+                                               rte_pktmbuf_free(pkt);
+                                               ++rxq->stats.rx_nombuf;
+                                               goto out;
+                                       }
+                                       NEXT(prev) = next;
+                                       SET_DATA_OFF(next, 0);
+                                       addr = RTE_PTR_ADD(addr, seg_len);
+                                       seg_len = RTE_MIN
+                                               (rte_pktmbuf_tailroom(next),
+                                                rem_len);
+                                       rte_memcpy
+                                               (rte_pktmbuf_mtod(next, void *),
+                                                addr, seg_len);
+                                       DATA_LEN(next) = seg_len;
+                                       rem_len -= seg_len;
+                                       prev = next;
+                                       ++NB_SEGS(pkt);
+                               }
+                       } else {
                                rte_pktmbuf_free_seg(pkt);
                                ++rxq->stats.idropped;
                                continue;
                        }
-                       rte_memcpy(rte_pktmbuf_mtod(pkt, void *), addr, len);
-                       DATA_LEN(pkt) = len;
                } else {
                        rte_iova_t buf_iova;
                        struct rte_mbuf_ext_shared_info *shinfo;
@@ -1826,6 +1859,7 @@ mlx5_rx_burst_mprq(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
                *(pkts++) = pkt;
                ++i;
        }
+out:
        /* Update the consumer indexes. */
        rxq->consumed_strd = consumed_strd;
        rte_cio_wmb();
@@ -4816,7 +4850,7 @@ send_loop:
        /*
         * Calculate the number of available resources - elts and WQEs.
         * There are two possible different scenarios:
-        * - no data inlining into WQEs, one WQEBB may contains upto
+        * - no data inlining into WQEs, one WQEBB may contains up to
         *   four packets, in this case elts become scarce resource
         * - data inlining into WQEs, one packet may require multiple
         *   WQEBBs, the WQEs become the limiting factor.