lib/librte_compressdev/rte_comp.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017-2018 Intel Corporation
   3  */
   4
   5 #include "rte_comp.h"
   6 #include "rte_compressdev.h"
   7 #include "rte_compressdev_internal.h"
   8
   9 const char * __rte_experimental
  10 rte_comp_get_feature_name(uint64_t flag)
  11 {
  12         switch (flag) {
  13         case RTE_COMP_FF_STATEFUL_COMPRESSION:
  14                 return "STATEFUL_COMPRESSION";
  15         case RTE_COMP_FF_STATEFUL_DECOMPRESSION:
  16                 return "STATEFUL_DECOMPRESSION";
  17         case RTE_COMP_FF_OOP_SGL_IN_SGL_OUT:
  18                 return "OOP_SGL_IN_SGL_OUT";
  19         case RTE_COMP_FF_OOP_SGL_IN_LB_OUT:
  20                 return "OOP_SGL_IN_LB_OUT";
  21         case RTE_COMP_FF_OOP_LB_IN_SGL_OUT:
  22                 return "OOP_LB_IN_SGL_OUT";
  23         case RTE_COMP_FF_MULTI_PKT_CHECKSUM:
  24                 return "MULTI_PKT_CHECKSUM";
  25         case RTE_COMP_FF_ADLER32_CHECKSUM:
  26                 return "ADLER32_CHECKSUM";
  27         case RTE_COMP_FF_CRC32_CHECKSUM:
  28                 return "CRC32_CHECKSUM";
  29         case RTE_COMP_FF_CRC32_ADLER32_CHECKSUM:
  30                 return "CRC32_ADLER32_CHECKSUM";
  31         case RTE_COMP_FF_NONCOMPRESSED_BLOCKS:
  32                 return "NONCOMPRESSED_BLOCKS";
  33         case RTE_COMP_FF_SHA1_HASH:
  34                 return "SHA1_HASH";
  35         case RTE_COMP_FF_SHA2_SHA256_HASH:
  36                 return "SHA2_SHA256_HASH";
  37         case RTE_COMP_FF_SHAREABLE_PRIV_XFORM:
  38                 return "SHAREABLE_PRIV_XFORM";
  39         default:
  40                 return NULL;
  41         }
  42 }
  43
  44 /**
  45  * Reset the fields of an operation to their default values.
  46  *
  47  * @note The private data associated with the operation is not zeroed.
  48  *
  49  * @param op
  50  *   The operation to be reset
  51  */
  52 static inline void
  53 rte_comp_op_reset(struct rte_comp_op *op)
  54 {
  55         struct rte_mempool *tmp_mp = op->mempool;
  56         rte_iova_t tmp_iova_addr = op->iova_addr;
  57
  58         memset(op, 0, sizeof(struct rte_comp_op));
  59         op->status = RTE_COMP_OP_STATUS_NOT_PROCESSED;
  60         op->iova_addr = tmp_iova_addr;
  61         op->mempool = tmp_mp;
  62 }
  63
  64 /**
  65  * Private data structure belonging to an operation pool.
  66  */
  67 struct rte_comp_op_pool_private {
  68         uint16_t user_size;
  69         /**< Size of private user data with each operation. */
  70 };
  71
  72 /**
  73  * Bulk allocate raw element from mempool and return as comp operations
  74  *
  75  * @param mempool
  76  *   Compress operation mempool
  77  * @param ops
  78  *   Array to place allocated operations
  79  * @param nb_ops
  80  *   Number of operations to allocate
  81  * @return
  82  *   - 0: Success
  83  *   - -ENOENT: Not enough entries in the mempool; no ops are retrieved.
  84  */
  85 static inline int
  86 rte_comp_op_raw_bulk_alloc(struct rte_mempool *mempool,
  87                 struct rte_comp_op **ops, uint16_t nb_ops)
  88 {
  89         if (rte_mempool_get_bulk(mempool, (void **)ops, nb_ops) == 0)
  90                 return nb_ops;
  91
  92         return 0;
  93 }
  94
  95 /** Initialise rte_comp_op mempool element */
  96 static void
  97 rte_comp_op_init(struct rte_mempool *mempool,
  98                 __rte_unused void *opaque_arg,
  99                 void *_op_data,
 100                 __rte_unused unsigned int i)
 101 {
 102         struct rte_comp_op *op = _op_data;
 103
 104         memset(_op_data, 0, mempool->elt_size);
 105
 106         op->status = RTE_COMP_OP_STATUS_NOT_PROCESSED;
 107         op->iova_addr = rte_mem_virt2iova(_op_data);
 108         op->mempool = mempool;
 109 }
 110
 111 struct rte_mempool * __rte_experimental
 112 rte_comp_op_pool_create(const char *name,
 113                 unsigned int nb_elts, unsigned int cache_size,
 114                 uint16_t user_size, int socket_id)
 115 {
 116         struct rte_comp_op_pool_private *priv;
 117
 118         unsigned int elt_size = sizeof(struct rte_comp_op) + user_size;
 119
 120         /* lookup mempool in case already allocated */
 121         struct rte_mempool *mp = rte_mempool_lookup(name);
 122
 123         if (mp != NULL) {
 124                 priv = (struct rte_comp_op_pool_private *)
 125                                 rte_mempool_get_priv(mp);
 126
 127                 if (mp->elt_size != elt_size ||
 128                                 mp->cache_size < cache_size ||
 129                                 mp->size < nb_elts ||
 130                                 priv->user_size <  user_size) {
 131                         mp = NULL;
 132                         COMPRESSDEV_LOG(ERR,
 133                 "Mempool %s already exists but with incompatible parameters",
 134                                         name);
 135                         return NULL;
 136                 }
 137                 return mp;
 138         }
 139
 140         mp = rte_mempool_create(
 141                         name,
 142                         nb_elts,
 143                         elt_size,
 144                         cache_size,
 145                         sizeof(struct rte_comp_op_pool_private),
 146                         NULL,
 147                         NULL,
 148                         rte_comp_op_init,
 149                         NULL,
 150                         socket_id,
 151                         0);
 152
 153         if (mp == NULL) {
 154                 COMPRESSDEV_LOG(ERR, "Failed to create mempool %s", name);
 155                 return NULL;
 156         }
 157
 158         priv = (struct rte_comp_op_pool_private *)
 159                         rte_mempool_get_priv(mp);
 160
 161         priv->user_size = user_size;
 162
 163         return mp;
 164 }
 165
 166 struct rte_comp_op * __rte_experimental
 167 rte_comp_op_alloc(struct rte_mempool *mempool)
 168 {
 169         struct rte_comp_op *op = NULL;
 170         int retval;
 171
 172         retval = rte_comp_op_raw_bulk_alloc(mempool, &op, 1);
 173         if (unlikely(retval < 0))
 174                 return NULL;
 175
 176         rte_comp_op_reset(op);
 177
 178         return op;
 179 }
 180
 181 int __rte_experimental
 182 rte_comp_op_bulk_alloc(struct rte_mempool *mempool,
 183                 struct rte_comp_op **ops, uint16_t nb_ops)
 184 {
 185         int ret;
 186         uint16_t i;
 187
 188         ret = rte_comp_op_raw_bulk_alloc(mempool, ops, nb_ops);
 189         if (unlikely(ret < nb_ops))
 190                 return ret;
 191
 192         for (i = 0; i < nb_ops; i++)
 193                 rte_comp_op_reset(ops[i]);
 194
 195         return nb_ops;
 196 }
 197
 198 /**
 199  * free operation structure
 200  * If operation has been allocate from a rte_mempool, then the operation will
 201  * be returned to the mempool.
 202  *
 203  * @param op
 204  *   Compress operation
 205  */
 206 void __rte_experimental
 207 rte_comp_op_free(struct rte_comp_op *op)
 208 {
 209         if (op != NULL && op->mempool != NULL)
 210                 rte_mempool_put(op->mempool, op);
 211 }