compress/isal: support chained mbufs

This patch adds chained mbuf support for input or output buffers
during compression/decompression operations.

Signed-off-by: Lee Daly <lee.daly@intel.com>
Reviewed-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>

diff --git a/doc/guides/compressdevs/features/isal.ini b/doc/guides/compressdevs/features/isal.ini
index 7183d10..919cf70 100644 (file)
--- a/doc/guides/compressdevs/features/isal.ini
+++ b/doc/guides/compressdevs/features/isal.ini
@@ -4,10 +4,13 @@
 ; Supported features of 'ISA-L' compression driver.
 ;
 [Features]
-CPU SSE        = Y
-CPU AVX        = Y
-CPU AVX2       = Y
-CPU AVX512     = Y
-Deflate        = Y
-Fixed          = Y
-Dynamic        = Y
+CPU SSE            = Y
+CPU AVX            = Y
+CPU AVX2           = Y
+CPU AVX512         = Y
+OOP SGL In SGL Out = Y
+OOP SGL In LB  Out = Y
+OOP LB  In SGL Out = Y
+Deflate            = Y
+Fixed              = Y
+Dynamic            = Y

diff --git a/doc/guides/compressdevs/isal.rst b/doc/guides/compressdevs/isal.rst
index 276ff06..3bc3022 100644 (file)
--- a/doc/guides/compressdevs/isal.rst
+++ b/doc/guides/compressdevs/isal.rst
@@ -78,8 +78,6 @@ As a result the level mappings from the API to the PMD are shown below.
 Limitations
 -----------
 
-* Chained mbufs will not be supported until a future release, meaning max data size being passed to PMD through a single mbuf is 64K - 1. If data is larger than this it will need to be split up and sent as multiple operations.
-
 * Compressdev level 0, no compression, is not supported.
 
 * Checksums will not be supported until future release.

diff --git a/doc/guides/rel_notes/release_18_08.rst b/doc/guides/rel_notes/release_18_08.rst
index 1ca7cb9..48380de 100644 (file)
--- a/doc/guides/rel_notes/release_18_08.rst
+++ b/doc/guides/rel_notes/release_18_08.rst
@@ -86,6 +86,10 @@ New Features
   operations in software. See the :doc:`../compressdevs/qat_comp` compression
   driver guide for details on this new driver.
 
+* **Updated the ISA-L PMD.**
+
+  Added support for chained mbufs (input and output).
+
 
 API Changes
 -----------

diff --git a/drivers/compress/isal/isal_compress_pmd.c b/drivers/compress/isal/isal_compress_pmd.c
index 5966cc3..e75f48d 100644 (file)
--- a/drivers/compress/isal/isal_compress_pmd.c
+++ b/drivers/compress/isal/isal_compress_pmd.c
@@ -188,6 +188,179 @@ isal_comp_set_priv_xform_parameters(struct isal_priv_xform *priv_xform,
        return 0;
 }
 
+/* Compression using chained mbufs for input/output data */
+static int
+chained_mbuf_compression(struct rte_comp_op *op, struct isal_comp_qp *qp)
+{
+       int ret;
+       uint32_t remaining_offset;
+       uint32_t remaining_data = op->src.length;
+       struct rte_mbuf *src = op->m_src;
+       struct rte_mbuf *dst = op->m_dst;
+
+       /* check for source/destination offset passing multiple segments
+        * and point compression stream to input/output buffer.
+        */
+       remaining_offset = op->src.offset;
+       while (remaining_offset >= src->data_len) {
+               remaining_offset -= src->data_len;
+               src = src->next;
+       }
+       qp->stream->avail_in = RTE_MIN(src->data_len - remaining_offset,
+                       op->src.length);
+       qp->stream->next_in = rte_pktmbuf_mtod_offset(src, uint8_t *,
+                       remaining_offset);
+
+       remaining_offset = op->dst.offset;
+       while (remaining_offset >= dst->data_len) {
+               remaining_offset -= dst->data_len;
+               dst = dst->next;
+       }
+       qp->stream->avail_out = dst->data_len - remaining_offset;
+       qp->stream->next_out = rte_pktmbuf_mtod_offset(dst, uint8_t *,
+                       remaining_offset);
+
+       if (unlikely(!qp->stream->next_in || !qp->stream->next_out)) {
+               ISAL_PMD_LOG(ERR, "Invalid source or destination buffer\n");
+               op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
+               return -1;
+       }
+
+       while (qp->stream->internal_state.state != ZSTATE_END) {
+               /* Last segment of data */
+               if (remaining_data <= src->data_len)
+                       qp->stream->end_of_stream = 1;
+
+               /* Execute compression operation */
+               ret = isal_deflate(qp->stream);
+
+               remaining_data = op->src.length - qp->stream->total_in;
+
+               if (ret != COMP_OK) {
+                       ISAL_PMD_LOG(ERR, "Compression operation failed\n");
+                       op->status = RTE_COMP_OP_STATUS_ERROR;
+                       return ret;
+               }
+
+               if (qp->stream->avail_in == 0 &&
+                               qp->stream->total_in != op->src.length) {
+                       if (src->next != NULL) {
+                               src = src->next;
+                               qp->stream->next_in =
+                                               rte_pktmbuf_mtod(src, uint8_t *);
+                               qp->stream->avail_in =
+                                       RTE_MIN(remaining_data, src->data_len);
+                       } else {
+                               ISAL_PMD_LOG(ERR,
+                               "Not enough input buffer segments\n");
+                               op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
+                               return -1;
+                       }
+               }
+
+               if (qp->stream->avail_out == 0 &&
+                               qp->stream->internal_state.state != ZSTATE_END) {
+                       if (dst->next != NULL) {
+                               dst = dst->next;
+                               qp->stream->next_out =
+                                               rte_pktmbuf_mtod(dst, uint8_t *);
+                               qp->stream->avail_out = dst->data_len;
+                       } else {
+                               ISAL_PMD_LOG(ERR,
+                               "Not enough output buffer segments\n");
+                               op->status =
+                               RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED;
+                               return -1;
+                       }
+               }
+       }
+
+       return 0;
+}
+
+/* Decompression using chained mbufs for input/output data */
+static int
+chained_mbuf_decompression(struct rte_comp_op *op, struct isal_comp_qp *qp)
+{
+       int ret;
+       uint32_t consumed_data, src_remaining_offset, dst_remaining_offset;
+       uint32_t remaining_data = op->src.length;
+       struct rte_mbuf *src = op->m_src;
+       struct rte_mbuf *dst = op->m_dst;
+
+       /* check for offset passing multiple segments
+        * and point decompression state to input/output buffer
+        */
+       src_remaining_offset = op->src.offset;
+       while (src_remaining_offset >= src->data_len) {
+               src_remaining_offset -= src->data_len;
+               src = src->next;
+       }
+       qp->state->avail_in = RTE_MIN(src->data_len - src_remaining_offset,
+                       op->src.length);
+       qp->state->next_in = rte_pktmbuf_mtod_offset(src, uint8_t *,
+                       src_remaining_offset);
+
+       dst_remaining_offset = op->dst.offset;
+       while (dst_remaining_offset >= dst->data_len) {
+               dst_remaining_offset -= dst->data_len;
+               dst = dst->next;
+       }
+       qp->state->avail_out = dst->data_len - dst_remaining_offset;
+       qp->state->next_out = rte_pktmbuf_mtod_offset(dst, uint8_t *,
+                       dst_remaining_offset);
+
+       while (qp->state->block_state != ISAL_BLOCK_FINISH) {
+
+               ret = isal_inflate(qp->state);
+
+               /* Check for first segment, offset needs to be accounted for */
+               if (remaining_data == op->src.length) {
+                       consumed_data = src->data_len - qp->state->avail_in -
+                                       src_remaining_offset;
+               } else
+                       consumed_data = src->data_len - qp->state->avail_in;
+
+               op->consumed += consumed_data;
+               remaining_data -= consumed_data;
+
+               if (ret != ISAL_DECOMP_OK) {
+                       ISAL_PMD_LOG(ERR, "Decompression operation failed\n");
+                       op->status = RTE_COMP_OP_STATUS_ERROR;
+                       return ret;
+               }
+
+               if (qp->state->avail_in == 0
+                               && op->consumed != op->src.length) {
+                       if (src->next != NULL) {
+                               src = src->next;
+                               qp->state->next_in =
+                                               rte_pktmbuf_mtod(src, uint8_t *);
+                               qp->state->avail_in =
+                                       RTE_MIN(remaining_data, src->data_len);
+                       }
+               }
+
+               if (qp->state->avail_out == 0 &&
+                               qp->state->block_state != ISAL_BLOCK_FINISH) {
+                       if (dst->next != NULL) {
+                               dst = dst->next;
+                               qp->state->next_out =
+                                               rte_pktmbuf_mtod(dst, uint8_t *);
+                               qp->state->avail_out = dst->data_len;
+                       } else {
+                               ISAL_PMD_LOG(ERR,
+                               "Not enough output buffer segments\n");
+                               op->status =
+                               RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED;
+                               return -1;
+                       }
+               }
+       }
+
+       return 0;
+}
+
 /* Stateless Compression Function */
 static int
 process_isal_deflate(struct rte_comp_op *op, struct isal_comp_qp *qp,
@@ -207,7 +380,7 @@ process_isal_deflate(struct rte_comp_op *op, struct isal_comp_qp *qp,
        /* Stateless operation, input will be consumed in one go */
        qp->stream->flush = NO_FLUSH;
 
-       /* set op level & intermediate level buffer */
+       /* set compression level & intermediate level buffer size */
        qp->stream->level = priv_xform->compress.level;
        qp->stream->level_buf_size = priv_xform->level_buffer_size;
 
@@ -225,59 +398,70 @@ process_isal_deflate(struct rte_comp_op *op, struct isal_comp_qp *qp,
                isal_deflate_set_hufftables(qp->stream, NULL,
                                IGZIP_HUFFTABLE_DEFAULT);
 
-       qp->stream->end_of_stream = 1; /* All input consumed in one go */
-       if ((op->src.length + op->src.offset) > op->m_src->data_len) {
-               ISAL_PMD_LOG(ERR, "Input mbuf not big enough for the length and"
-                               " offset provided.\n");
+       if (op->m_src->pkt_len < (op->src.length + op->src.offset)) {
+               ISAL_PMD_LOG(ERR, "Input mbuf(s) not big enough.\n");
                op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
                return -1;
        }
-       /* Point compression stream to input buffer */
-       qp->stream->avail_in = op->src.length;
-       qp->stream->next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *,
-                       op->src.offset);
 
-       if (op->dst.offset > op->m_dst->data_len) {
-               ISAL_PMD_LOG(ERR, "Output mbuf not big enough for the length"
+       if (op->dst.offset > op->m_dst->pkt_len) {
+               ISAL_PMD_LOG(ERR, "Output mbuf(s) not big enough for length"
                                " and offset provided.\n");
                op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
                return -1;
        }
-       /*  Point compression stream to output buffer */
-       qp->stream->avail_out = op->m_dst->data_len - op->dst.offset;
-       qp->stream->next_out  = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *,
-               op->dst.offset);
 
-       if (unlikely(!qp->stream->next_in || !qp->stream->next_out)) {
-               ISAL_PMD_LOG(ERR, "Invalid source or destination buffers\n");
-               op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
-               return -1;
-       }
+       /* Chained mbufs */
+       if (op->m_src->nb_segs > 1 || op->m_dst->nb_segs > 1) {
+               ret = chained_mbuf_compression(op, qp);
+               if (ret < 0)
+                       return ret;
+       } else {
+               /* Linear buffer */
+               qp->stream->end_of_stream = 1; /* All input consumed in one */
+               /* Point compression stream to input buffer */
+               qp->stream->avail_in = op->src.length;
+               qp->stream->next_in = rte_pktmbuf_mtod_offset(op->m_src,
+                               uint8_t *, op->src.offset);
+
+               /*  Point compression stream to output buffer */
+               qp->stream->avail_out = op->m_dst->data_len - op->dst.offset;
+               qp->stream->next_out  = rte_pktmbuf_mtod_offset(op->m_dst,
+                               uint8_t *, op->dst.offset);
+
+               if (unlikely(!qp->stream->next_in || !qp->stream->next_out)) {
+                       ISAL_PMD_LOG(ERR, "Invalid source or destination"
+                                       " buffers\n");
+                       op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
+                       return -1;
+               }
 
-       /* Execute compression operation */
-       ret =  isal_deflate_stateless(qp->stream);
+               /* Execute compression operation */
+               ret =  isal_deflate_stateless(qp->stream);
 
-       /* Check that output buffer did not run out of space */
-       if (ret == STATELESS_OVERFLOW) {
-               ISAL_PMD_LOG(ERR, "Output buffer not big enough\n");
-               op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED;
-               return ret;
-       }
+               /* Check that output buffer did not run out of space */
+               if (ret == STATELESS_OVERFLOW) {
+                       ISAL_PMD_LOG(ERR, "Output buffer not big enough\n");
+                       op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED;
+                       return ret;
+               }
 
-       /* Check that input buffer has been fully consumed */
-       if (qp->stream->avail_in != (uint32_t)0) {
-               ISAL_PMD_LOG(ERR, "Input buffer could not be read entirely\n");
-               op->status = RTE_COMP_OP_STATUS_ERROR;
-               return -1;
-       }
+               /* Check that input buffer has been fully consumed */
+               if (qp->stream->avail_in != (uint32_t)0) {
+                       ISAL_PMD_LOG(ERR, "Input buffer could not be read"
+                                       " entirely\n");
+                       op->status = RTE_COMP_OP_STATUS_ERROR;
+                       return -1;
+               }
 
-       if (ret != COMP_OK) {
-               op->status = RTE_COMP_OP_STATUS_ERROR;
-               return ret;
+               if (ret != COMP_OK) {
+                       ISAL_PMD_LOG(ERR, "Compression operation failed\n");
+                       op->status = RTE_COMP_OP_STATUS_ERROR;
+                       return ret;
+               }
        }
-
-       op->consumed = qp->stream->total_in;
-       op->produced = qp->stream->total_out;
+               op->consumed = qp->stream->total_in;
+               op->produced = qp->stream->total_out;
 
        return ret;
 }
@@ -293,59 +477,69 @@ process_isal_inflate(struct rte_comp_op *op, struct isal_comp_qp *qp)
        /* Initialize decompression state */
        isal_inflate_init(qp->state);
 
-       if ((op->src.length + op->src.offset) > op->m_src->data_len) {
-               ISAL_PMD_LOG(ERR, "Input mbuf not big enough for the length and"
-                               " offset provided.\n");
+       if (op->m_src->pkt_len < (op->src.length + op->src.offset)) {
+               ISAL_PMD_LOG(ERR, "Input mbuf(s) not big enough.\n");
                op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
                return -1;
        }
-       /* Point decompression state to input buffer */
-       qp->state->avail_in = op->src.length;
-       qp->state->next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *,
-                       op->src.offset);
 
        if (op->dst.offset > op->m_dst->data_len) {
-               ISAL_PMD_LOG(ERR, "Output mbuf not big enough for the length "
-                               "and offset provided.\n");
+               ISAL_PMD_LOG(ERR, "Output mbuf not big enough for length and "
+                               "offset provided.\n");
                op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
                return -1;
        }
-       /* Point decompression state to output buffer */
-       qp->state->avail_out = op->m_dst->data_len - op->dst.offset;
-       qp->state->next_out  = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *,
-                       op->dst.offset);
 
-       if (unlikely(!qp->state->next_in || !qp->state->next_out)) {
-               ISAL_PMD_LOG(ERR, "Invalid source or destination buffers\n");
-               op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
-               return -1;
-       }
+       /* Chained mbufs */
+       if (op->m_src->nb_segs > 1 || op->m_dst->nb_segs > 1) {
+               ret = chained_mbuf_decompression(op, qp);
+               if (ret !=  0)
+                       return ret;
+       } else {
+               /* Linear buffer */
+               /* Point decompression state to input buffer */
+               qp->state->avail_in = op->src.length;
+               qp->state->next_in = rte_pktmbuf_mtod_offset(op->m_src,
+                               uint8_t *, op->src.offset);
+
+               /* Point decompression state to output buffer */
+               qp->state->avail_out = op->m_dst->data_len - op->dst.offset;
+               qp->state->next_out  = rte_pktmbuf_mtod_offset(op->m_dst,
+                               uint8_t *, op->dst.offset);
+
+               if (unlikely(!qp->state->next_in || !qp->state->next_out)) {
+                       ISAL_PMD_LOG(ERR, "Invalid source or destination"
+                                       " buffers\n");
+                       op->status = RTE_COMP_OP_STATUS_INVALID_ARGS;
+                       return -1;
+               }
 
-       /* Execute decompression operation */
-       ret = isal_inflate_stateless(qp->state);
+               /* Execute decompression operation */
+               ret = isal_inflate_stateless(qp->state);
 
-       if (ret == ISAL_OUT_OVERFLOW) {
-               ISAL_PMD_LOG(ERR, "Output buffer not big enough\n");
-               op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED;
-               return ret;
-       }
+               if (ret == ISAL_OUT_OVERFLOW) {
+                       ISAL_PMD_LOG(ERR, "Output buffer not big enough\n");
+                       op->status = RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED;
+                       return ret;
+               }
 
-       /* Check that input buffer has been fully consumed */
-       if (qp->state->avail_in != (uint32_t)0) {
-               ISAL_PMD_LOG(ERR, "Input buffer could not be read entirely\n");
-               op->status = RTE_COMP_OP_STATUS_ERROR;
-               return -1;
-       }
+               /* Check that input buffer has been fully consumed */
+               if (qp->state->avail_in != (uint32_t)0) {
+                       ISAL_PMD_LOG(ERR, "Input buffer could not be read"
+                                       " entirely\n");
+                       op->status = RTE_COMP_OP_STATUS_ERROR;
+                       return -1;
+               }
 
-       if (ret != ISAL_DECOMP_OK) {
-               op->status = RTE_COMP_OP_STATUS_ERROR;
-               return ret;
+               if (ret != ISAL_DECOMP_OK) {
+                       op->status = RTE_COMP_OP_STATUS_ERROR;
+                       return ret;
+               }
+               op->consumed = op->src.length - qp->state->avail_in;
        }
+               op->produced = qp->state->total_out;
 
-       op->consumed = op->src.length - qp->state->avail_in;
-       op->produced = qp->state->total_out;
-
-return ret;
+       return ret;
 }
 
 /* Process compression/decompression operation */

diff --git a/drivers/compress/isal/isal_compress_pmd_ops.c b/drivers/compress/isal/isal_compress_pmd_ops.c
index c61acd4..41cade8 100644 (file)
--- a/drivers/compress/isal/isal_compress_pmd_ops.c
+++ b/drivers/compress/isal/isal_compress_pmd_ops.c
@@ -12,7 +12,10 @@
 static const struct rte_compressdev_capabilities isal_pmd_capabilities[] = {
        {
                .algo = RTE_COMP_ALGO_DEFLATE,
-               .comp_feature_flags =   RTE_COMP_FF_SHAREABLE_PRIV_XFORM |
+               .comp_feature_flags =   RTE_COMP_FF_OOP_SGL_IN_SGL_OUT |
+                                       RTE_COMP_FF_OOP_SGL_IN_LB_OUT |
+                                       RTE_COMP_FF_OOP_LB_IN_SGL_OUT |
+                                       RTE_COMP_FF_SHAREABLE_PRIV_XFORM |
                                        RTE_COMP_FF_HUFFMAN_FIXED |
                                        RTE_COMP_FF_HUFFMAN_DYNAMIC,
                .window_size = {