compress/zlib: create private xform

Create non-shareable private xform for stateless
operation processing

Signed-off-by: Sunila Sahu <sunila.sahu@caviumnetworks.com>
Signed-off-by: Shally Verma <shally.verma@caviumnetworks.com>
Signed-off-by: Ashish Gupta <ashish.gupta@caviumnetworks.com>

diff --git a/drivers/compress/zlib/zlib_pmd.c b/drivers/compress/zlib/zlib_pmd.c
index 7aeef44..0d09c54 100644 (file)
--- a/drivers/compress/zlib/zlib_pmd.c
+++ b/drivers/compress/zlib/zlib_pmd.c
@@ -7,6 +7,100 @@
 
 #include "zlib_pmd_private.h"
 
+/** Parse comp xform and set private xform/stream parameters */
+int
+zlib_set_stream_parameters(const struct rte_comp_xform *xform,
+               struct zlib_stream *stream)
+{
+       int strategy, level, wbits;
+       z_stream *strm = &stream->strm;
+
+       /* allocate deflate state */
+       strm->zalloc = Z_NULL;
+       strm->zfree = Z_NULL;
+       strm->opaque = Z_NULL;
+
+       switch (xform->type) {
+       case RTE_COMP_COMPRESS:
+               /** Compression window bits */
+               switch (xform->compress.algo) {
+               case RTE_COMP_ALGO_DEFLATE:
+                       wbits = -(xform->compress.window_size);
+                       break;
+               default:
+                       ZLIB_PMD_ERR("Compression algorithm not supported\n");
+                       return -1;
+               }
+               /** Compression Level */
+               switch (xform->compress.level) {
+               case RTE_COMP_LEVEL_PMD_DEFAULT:
+                       level = Z_DEFAULT_COMPRESSION;
+                       break;
+               case RTE_COMP_LEVEL_NONE:
+                       level = Z_NO_COMPRESSION;
+                       break;
+               case RTE_COMP_LEVEL_MIN:
+                       level = Z_BEST_SPEED;
+                       break;
+               case RTE_COMP_LEVEL_MAX:
+                       level = Z_BEST_COMPRESSION;
+                       break;
+               default:
+                       level = xform->compress.level;
+                       if (level < RTE_COMP_LEVEL_MIN ||
+                                       level > RTE_COMP_LEVEL_MAX) {
+                               ZLIB_PMD_ERR("Compression level %d "
+                                               "not supported\n",
+                                               level);
+                               return -1;
+                       }
+                       break;
+               }
+               /** Compression strategy */
+               switch (xform->compress.deflate.huffman) {
+               case RTE_COMP_HUFFMAN_DEFAULT:
+                       strategy = Z_DEFAULT_STRATEGY;
+                       break;
+               case RTE_COMP_HUFFMAN_FIXED:
+                       strategy = Z_FIXED;
+                       break;
+               case RTE_COMP_HUFFMAN_DYNAMIC:
+                       strategy = Z_DEFAULT_STRATEGY;
+                       break;
+               default:
+                       ZLIB_PMD_ERR("Compression strategy not supported\n");
+                       return -1;
+               }
+               if (deflateInit2(strm, level,
+                                       Z_DEFLATED, wbits,
+                                       DEF_MEM_LEVEL, strategy) != Z_OK) {
+                       ZLIB_PMD_ERR("Deflate init failed\n");
+                       return -1;
+               }
+               break;
+
+       case RTE_COMP_DECOMPRESS:
+               /** window bits */
+               switch (xform->decompress.algo) {
+               case RTE_COMP_ALGO_DEFLATE:
+                       wbits = -(xform->decompress.window_size);
+                       break;
+               default:
+                       ZLIB_PMD_ERR("Compression algorithm not supported\n");
+                       return -1;
+               }
+
+               if (inflateInit2(strm, wbits) != Z_OK) {
+                       ZLIB_PMD_ERR("Inflate init failed\n");
+                       return -1;
+               }
+               break;
+       default:
+               return -1;
+       }
+       return 0;
+}
+
 static int
 zlib_create(const char *name,
                struct rte_vdev_device *vdev,

diff --git a/drivers/compress/zlib/zlib_pmd_ops.c b/drivers/compress/zlib/zlib_pmd_ops.c
index cf9c006..0a73aed 100644 (file)
--- a/drivers/compress/zlib/zlib_pmd_ops.c
+++ b/drivers/compress/zlib/zlib_pmd_ops.c
@@ -213,6 +213,76 @@ qp_setup_cleanup:
        return -1;
 }
 
+/** Configure stream */
+static int
+zlib_pmd_stream_create(struct rte_compressdev *dev,
+               const struct rte_comp_xform *xform,
+               void **zstream)
+{
+       int ret = 0;
+       struct zlib_stream *stream;
+       struct zlib_private *internals = dev->data->dev_private;
+
+       if (xform == NULL) {
+               ZLIB_PMD_ERR("invalid xform struct");
+               return -EINVAL;
+       }
+
+       if (rte_mempool_get(internals->mp, zstream)) {
+               ZLIB_PMD_ERR("Couldn't get object from session mempool");
+               return -ENOMEM;
+       }
+       stream = *((struct zlib_stream **)zstream);
+
+       ret = zlib_set_stream_parameters(xform, stream);
+
+       if (ret < 0) {
+               ZLIB_PMD_ERR("failed configure session parameters");
+
+               memset(stream, 0, sizeof(struct zlib_stream));
+               /* Return session to mempool */
+               rte_mempool_put(internals->mp, stream);
+               return ret;
+       }
+
+       return 0;
+}
+
+/** Configure private xform */
+static int
+zlib_pmd_private_xform_create(struct rte_compressdev *dev,
+               const struct rte_comp_xform *xform,
+               void **private_xform)
+{
+       return zlib_pmd_stream_create(dev, xform, private_xform);
+}
+
+/** Clear the memory of stream so it doesn't leave key material behind */
+static int
+zlib_pmd_stream_free(__rte_unused struct rte_compressdev *dev,
+               void *zstream)
+{
+       struct zlib_stream *stream = (struct zlib_stream *)zstream;
+       if (!stream)
+               return -EINVAL;
+
+       stream->free(&stream->strm);
+       /* Zero out the whole structure */
+       memset(stream, 0, sizeof(struct zlib_stream));
+       struct rte_mempool *mp = rte_mempool_from_obj(stream);
+       rte_mempool_put(mp, stream);
+
+       return 0;
+}
+
+/** Clear the memory of stream so it doesn't leave key material behind */
+static int
+zlib_pmd_private_xform_free(struct rte_compressdev *dev,
+               void *private_xform)
+{
+       return zlib_pmd_stream_free(dev, private_xform);
+}
+
 struct rte_compressdev_ops zlib_pmd_ops = {
                .dev_configure          = zlib_pmd_config,
                .dev_start              = zlib_pmd_start,
@@ -227,8 +297,8 @@ struct rte_compressdev_ops zlib_pmd_ops = {
                .queue_pair_setup       = zlib_pmd_qp_setup,
                .queue_pair_release     = zlib_pmd_qp_release,
 
-               .private_xform_create   = NULL,
-               .private_xform_free     = NULL,
+               .private_xform_create   = zlib_pmd_private_xform_create,
+               .private_xform_free     = zlib_pmd_private_xform_free,
 
                .stream_create  = NULL,
                .stream_free    = NULL

diff --git a/drivers/compress/zlib/zlib_pmd_private.h b/drivers/compress/zlib/zlib_pmd_private.h
index 0e391a4..2c6e83d 100644 (file)
--- a/drivers/compress/zlib/zlib_pmd_private.h
+++ b/drivers/compress/zlib/zlib_pmd_private.h
@@ -61,6 +61,10 @@ struct zlib_priv_xform {
        struct zlib_stream stream;
 } __rte_cache_aligned;
 
+int
+zlib_set_stream_parameters(const struct rte_comp_xform *xform,
+               struct zlib_stream *stream);
+
 /** Device specific operations function pointer structure */
 extern struct rte_compressdev_ops *rte_zlib_pmd_ops;