compress/qat: fix overflow status return

[dpdk.git] / drivers / compress / qat / qat_comp.c

diff --git a/drivers/compress/qat/qat_comp.c b/drivers/compress/qat/qat_comp.c
index b9367d3..835aaa8 100644 (file)
--- a/drivers/compress/qat/qat_comp.c
+++ b/drivers/compress/qat/qat_comp.c
@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2018 Intel Corporation
+ * Copyright(c) 2018-2019 Intel Corporation
  */
 
 #include <rte_mempool.h>
@@ -79,22 +79,70 @@ qat_comp_build_request(void *in_op, uint8_t *out_msg,
                ICP_QAT_FW_COMN_PTR_TYPE_SET(comp_req->comn_hdr.comn_req_flags,
                                QAT_COMN_PTR_TYPE_SGL);
 
+               if (unlikely(op->m_src->nb_segs > cookie->src_nb_elems)) {
+                       /* we need to allocate more elements in SGL*/
+                       void *tmp;
+
+                       tmp = rte_realloc_socket(cookie->qat_sgl_src_d,
+                                         sizeof(struct qat_sgl) +
+                                         sizeof(struct qat_flat_buf) *
+                                         op->m_src->nb_segs, 64,
+                                         cookie->socket_id);
+
+                       if (unlikely(tmp == NULL)) {
+                               QAT_DP_LOG(ERR, "QAT PMD can't allocate memory"
+                                          " for %d elements of SGL",
+                                          op->m_src->nb_segs);
+                               op->status = RTE_COMP_OP_STATUS_ERROR;
+                               return -ENOMEM;
+                       }
+                       /* new SGL is valid now */
+                       cookie->qat_sgl_src_d = (struct qat_sgl *)tmp;
+                       cookie->src_nb_elems = op->m_src->nb_segs;
+                       cookie->qat_sgl_src_phys_addr =
+                               rte_malloc_virt2iova(cookie->qat_sgl_src_d);
+               }
+
                ret = qat_sgl_fill_array(op->m_src,
                                op->src.offset,
-                               &cookie->qat_sgl_src,
+                               cookie->qat_sgl_src_d,
                                op->src.length,
-                               RTE_PMD_QAT_COMP_SGL_MAX_SEGMENTS);
+                               cookie->src_nb_elems);
                if (ret) {
                        QAT_DP_LOG(ERR, "QAT PMD Cannot fill source sgl array");
                        op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
                        return ret;
                }
 
+               if (unlikely(op->m_dst->nb_segs > cookie->dst_nb_elems)) {
+                       /* we need to allocate more elements in SGL*/
+                       struct qat_sgl *tmp;
+
+                       tmp = rte_realloc_socket(cookie->qat_sgl_dst_d,
+                                         sizeof(struct qat_sgl) +
+                                         sizeof(struct qat_flat_buf) *
+                                         op->m_dst->nb_segs, 64,
+                                         cookie->socket_id);
+
+                       if (unlikely(tmp == NULL)) {
+                               QAT_DP_LOG(ERR, "QAT PMD can't allocate memory"
+                                          " for %d elements of SGL",
+                                          op->m_dst->nb_segs);
+                               op->status = RTE_COMP_OP_STATUS_ERROR;
+                               return -ENOMEM;
+                       }
+                       /* new SGL is valid now */
+                       cookie->qat_sgl_dst_d = (struct qat_sgl *)tmp;
+                       cookie->dst_nb_elems = op->m_dst->nb_segs;
+                       cookie->qat_sgl_dst_phys_addr =
+                               rte_malloc_virt2iova(cookie->qat_sgl_dst_d);
+               }
+
                ret = qat_sgl_fill_array(op->m_dst,
                                op->dst.offset,
-                               &cookie->qat_sgl_dst,
+                               cookie->qat_sgl_dst_d,
                                comp_req->comp_pars.out_buffer_sz,
-                               RTE_PMD_QAT_COMP_SGL_MAX_SEGMENTS);
+                               cookie->dst_nb_elems);
                if (ret) {
                        QAT_DP_LOG(ERR, "QAT PMD Cannot fill dest. sgl array");
                        op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
@@ -122,6 +170,18 @@ qat_comp_build_request(void *in_op, uint8_t *out_msg,
                    rte_pktmbuf_mtophys_offset(op->m_dst, op->dst.offset);
        }
 
+       if (unlikely(rte_pktmbuf_pkt_len(op->m_dst) < QAT_MIN_OUT_BUF_SIZE)) {
+               /* QAT doesn't support dest. buffer lower
+                * than QAT_MIN_OUT_BUF_SIZE. Propagate error mark
+                * by converting this request to the null one
+                * and check the status in the response.
+                */
+               QAT_DP_LOG(WARNING, "QAT destination buffer too small - resend with larger buffer");
+               comp_req->comn_hdr.service_type = ICP_QAT_FW_COMN_REQ_NULL;
+               comp_req->comn_hdr.service_cmd_id = ICP_QAT_FW_NULL_REQ_SERV_ID;
+               cookie->error = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED;
+       }
+
 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
        QAT_DP_LOG(DEBUG, "Direction: %s",
            qat_xform->qat_comp_request_type == QAT_COMP_REQUEST_DECOMPRESS ?
@@ -133,10 +193,13 @@ qat_comp_build_request(void *in_op, uint8_t *out_msg,
 }
 
 int
-qat_comp_process_response(void **op, uint8_t *resp, uint64_t *dequeue_err_count)
+qat_comp_process_response(void **op, uint8_t *resp, void *op_cookie,
+                         uint64_t *dequeue_err_count)
 {
        struct icp_qat_fw_comp_resp *resp_msg =
                        (struct icp_qat_fw_comp_resp *)resp;
+       struct qat_comp_op_cookie *cookie =
+                       (struct qat_comp_op_cookie *)op_cookie;
        struct rte_comp_op *rx_op = (struct rte_comp_op *)(uintptr_t)
                        (resp_msg->opaque_data);
        struct qat_comp_xform *qat_xform = (struct qat_comp_xform *)
@@ -153,6 +216,17 @@ qat_comp_process_response(void **op, uint8_t *resp, uint64_t *dequeue_err_count)
                        sizeof(struct icp_qat_fw_comp_resp));
 #endif
 
+       if (unlikely(cookie->error)) {
+               rx_op->status = cookie->error;
+               cookie->error = 0;
+               ++(*dequeue_err_count);
+               rx_op->debug_status = 0;
+               rx_op->consumed = 0;
+               rx_op->produced = 0;
+               *op = (void *)rx_op;
+               return 0;
+       }
+
        if (likely(qat_xform->qat_comp_request_type
                        != QAT_COMP_REQUEST_DECOMPRESS)) {
                if (unlikely(ICP_QAT_FW_COMN_HDR_CNV_FLAG_GET(