include/crypto/acompress.h

   1 /*
   2  * Asynchronous Compression operations
   3  *
   4  * Copyright (c) 2016, Intel Corporation
   5  * Authors: Weigang Li <weigang.li@intel.com>
   6  *          Giovanni Cabiddu <giovanni.cabiddu@intel.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the Free
  10  * Software Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  *
  13  */
  14 #ifndef _CRYPTO_ACOMP_H
  15 #define _CRYPTO_ACOMP_H
  16 #include <linux/crypto.h>
  17
  18 #define CRYPTO_ACOMP_ALLOC_OUTPUT       0x00000001
  19
  20 /**
  21  * struct acomp_req - asynchronous (de)compression request
  22  *
  23  * @base:       Common attributes for asynchronous crypto requests
  24  * @src:        Source Data
  25  * @dst:        Destination data
  26  * @slen:       Size of the input buffer
  27  * @dlen:       Size of the output buffer and number of bytes produced
  28  * @flags:      Internal flags
  29  * @__ctx:      Start of private context data
  30  */
  31 struct acomp_req {
  32         struct crypto_async_request base;
  33         struct scatterlist *src;
  34         struct scatterlist *dst;
  35         unsigned int slen;
  36         unsigned int dlen;
  37         u32 flags;
  38         void *__ctx[] CRYPTO_MINALIGN_ATTR;
  39 };
  40
  41 /**
  42  * struct crypto_acomp - user-instantiated objects which encapsulate
  43  * algorithms and core processing logic
  44  *
  45  * @compress:           Function performs a compress operation
  46  * @decompress:         Function performs a de-compress operation
  47  * @dst_free:           Frees destination buffer if allocated inside the
  48  *                      algorithm
  49  * @reqsize:            Context size for (de)compression requests
  50  * @base:               Common crypto API algorithm data structure
  51  */
  52 struct crypto_acomp {
  53         int (*compress)(struct acomp_req *req);
  54         int (*decompress)(struct acomp_req *req);
  55         void (*dst_free)(struct scatterlist *dst);
  56         unsigned int reqsize;
  57         struct crypto_tfm base;
  58 };
  59
  60 /**
  61  * struct acomp_alg - asynchronous compression algorithm
  62  *
  63  * @compress:   Function performs a compress operation
  64  * @decompress: Function performs a de-compress operation
  65  * @dst_free:   Frees destination buffer if allocated inside the algorithm
  66  * @init:       Initialize the cryptographic transformation object.
  67  *              This function is used to initialize the cryptographic
  68  *              transformation object. This function is called only once at
  69  *              the instantiation time, right after the transformation context
  70  *              was allocated. In case the cryptographic hardware has some
  71  *              special requirements which need to be handled by software, this
  72  *              function shall check for the precise requirement of the
  73  *              transformation and put any software fallbacks in place.
  74  * @exit:       Deinitialize the cryptographic transformation object. This is a
  75  *              counterpart to @init, used to remove various changes set in
  76  *              @init.
  77  *
  78  * @reqsize:    Context size for (de)compression requests
  79  * @base:       Common crypto API algorithm data structure
  80  */
  81 struct acomp_alg {
  82         int (*compress)(struct acomp_req *req);
  83         int (*decompress)(struct acomp_req *req);
  84         void (*dst_free)(struct scatterlist *dst);
  85         int (*init)(struct crypto_acomp *tfm);
  86         void (*exit)(struct crypto_acomp *tfm);
  87         unsigned int reqsize;
  88         struct crypto_alg base;
  89 };
  90
  91 /**
  92  * DOC: Asynchronous Compression API
  93  *
  94  * The Asynchronous Compression API is used with the algorithms of type
  95  * CRYPTO_ALG_TYPE_ACOMPRESS (listed as type "acomp" in /proc/crypto)
  96  */
  97
  98 /**
  99  * crypto_alloc_acomp() -- allocate ACOMPRESS tfm handle
 100  * @alg_name:   is the cra_name / name or cra_driver_name / driver name of the
 101  *              compression algorithm e.g. "deflate"
 102  * @type:       specifies the type of the algorithm
 103  * @mask:       specifies the mask for the algorithm
 104  *
 105  * Allocate a handle for a compression algorithm. The returned struct
 106  * crypto_acomp is the handle that is required for any subsequent
 107  * API invocation for the compression operations.
 108  *
 109  * Return:      allocated handle in case of success; IS_ERR() is true in case
 110  *              of an error, PTR_ERR() returns the error code.
 111  */
 112 struct crypto_acomp *crypto_alloc_acomp(const char *alg_name, u32 type,
 113                                         u32 mask);
 114
 115 static inline struct crypto_tfm *crypto_acomp_tfm(struct crypto_acomp *tfm)
 116 {
 117         return &tfm->base;
 118 }
 119
 120 static inline struct acomp_alg *__crypto_acomp_alg(struct crypto_alg *alg)
 121 {
 122         return container_of(alg, struct acomp_alg, base);
 123 }
 124
 125 static inline struct crypto_acomp *__crypto_acomp_tfm(struct crypto_tfm *tfm)
 126 {
 127         return container_of(tfm, struct crypto_acomp, base);
 128 }
 129
 130 static inline struct acomp_alg *crypto_acomp_alg(struct crypto_acomp *tfm)
 131 {
 132         return __crypto_acomp_alg(crypto_acomp_tfm(tfm)->__crt_alg);
 133 }
 134
 135 static inline unsigned int crypto_acomp_reqsize(struct crypto_acomp *tfm)
 136 {
 137         return tfm->reqsize;
 138 }
 139
 140 static inline void acomp_request_set_tfm(struct acomp_req *req,
 141                                          struct crypto_acomp *tfm)
 142 {
 143         req->base.tfm = crypto_acomp_tfm(tfm);
 144 }
 145
 146 static inline struct crypto_acomp *crypto_acomp_reqtfm(struct acomp_req *req)
 147 {
 148         return __crypto_acomp_tfm(req->base.tfm);
 149 }
 150
 151 /**
 152  * crypto_free_acomp() -- free ACOMPRESS tfm handle
 153  *
 154  * @tfm:        ACOMPRESS tfm handle allocated with crypto_alloc_acomp()
 155  */
 156 static inline void crypto_free_acomp(struct crypto_acomp *tfm)
 157 {
 158         crypto_destroy_tfm(tfm, crypto_acomp_tfm(tfm));
 159 }
 160
 161 static inline int crypto_has_acomp(const char *alg_name, u32 type, u32 mask)
 162 {
 163         type &= ~CRYPTO_ALG_TYPE_MASK;
 164         type |= CRYPTO_ALG_TYPE_ACOMPRESS;
 165         mask |= CRYPTO_ALG_TYPE_MASK;
 166
 167         return crypto_has_alg(alg_name, type, mask);
 168 }
 169
 170 /**
 171  * acomp_request_alloc() -- allocates asynchronous (de)compression request
 172  *
 173  * @tfm:        ACOMPRESS tfm handle allocated with crypto_alloc_acomp()
 174  *
 175  * Return:      allocated handle in case of success or NULL in case of an error
 176  */
 177 struct acomp_req *acomp_request_alloc(struct crypto_acomp *tfm);
 178
 179 /**
 180  * acomp_request_free() -- zeroize and free asynchronous (de)compression
 181  *                         request as well as the output buffer if allocated
 182  *                         inside the algorithm
 183  *
 184  * @req:        request to free
 185  */
 186 void acomp_request_free(struct acomp_req *req);
 187
 188 /**
 189  * acomp_request_set_callback() -- Sets an asynchronous callback
 190  *
 191  * Callback will be called when an asynchronous operation on a given
 192  * request is finished.
 193  *
 194  * @req:        request that the callback will be set for
 195  * @flgs:       specify for instance if the operation may backlog
 196  * @cmlp:       callback which will be called
 197  * @data:       private data used by the caller
 198  */
 199 static inline void acomp_request_set_callback(struct acomp_req *req,
 200                                               u32 flgs,
 201                                               crypto_completion_t cmpl,
 202                                               void *data)
 203 {
 204         req->base.complete = cmpl;
 205         req->base.data = data;
 206         req->base.flags = flgs;
 207 }
 208
 209 /**
 210  * acomp_request_set_params() -- Sets request parameters
 211  *
 212  * Sets parameters required by an acomp operation
 213  *
 214  * @req:        asynchronous compress request
 215  * @src:        pointer to input buffer scatterlist
 216  * @dst:        pointer to output buffer scatterlist. If this is NULL, the
 217  *              acomp layer will allocate the output memory
 218  * @slen:       size of the input buffer
 219  * @dlen:       size of the output buffer. If dst is NULL, this can be used by
 220  *              the user to specify the maximum amount of memory to allocate
 221  */
 222 static inline void acomp_request_set_params(struct acomp_req *req,
 223                                             struct scatterlist *src,
 224                                             struct scatterlist *dst,
 225                                             unsigned int slen,
 226                                             unsigned int dlen)
 227 {
 228         req->src = src;
 229         req->dst = dst;
 230         req->slen = slen;
 231         req->dlen = dlen;
 232
 233         if (!req->dst)
 234                 req->flags |= CRYPTO_ACOMP_ALLOC_OUTPUT;
 235 }
 236
 237 static inline void crypto_stat_compress(struct acomp_req *req, int ret)
 238 {
 239 #ifdef CONFIG_CRYPTO_STATS
 240         struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
 241
 242         if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
 243                 atomic_inc(&tfm->base.__crt_alg->compress_err_cnt);
 244         } else {
 245                 atomic_inc(&tfm->base.__crt_alg->compress_cnt);
 246                 atomic64_add(req->slen, &tfm->base.__crt_alg->compress_tlen);
 247         }
 248 #endif
 249 }
 250
 251 static inline void crypto_stat_decompress(struct acomp_req *req, int ret)
 252 {
 253 #ifdef CONFIG_CRYPTO_STATS
 254         struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
 255
 256         if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
 257                 atomic_inc(&tfm->base.__crt_alg->compress_err_cnt);
 258         } else {
 259                 atomic_inc(&tfm->base.__crt_alg->decompress_cnt);
 260                 atomic64_add(req->slen, &tfm->base.__crt_alg->decompress_tlen);
 261         }
 262 #endif
 263 }
 264
 265 /**
 266  * crypto_acomp_compress() -- Invoke asynchronous compress operation
 267  *
 268  * Function invokes the asynchronous compress operation
 269  *
 270  * @req:        asynchronous compress request
 271  *
 272  * Return:      zero on success; error code in case of error
 273  */
 274 static inline int crypto_acomp_compress(struct acomp_req *req)
 275 {
 276         struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
 277         int ret;
 278
 279         ret = tfm->compress(req);
 280         crypto_stat_compress(req, ret);
 281         return ret;
 282 }
 283
 284 /**
 285  * crypto_acomp_decompress() -- Invoke asynchronous decompress operation
 286  *
 287  * Function invokes the asynchronous decompress operation
 288  *
 289  * @req:        asynchronous compress request
 290  *
 291  * Return:      zero on success; error code in case of error
 292  */
 293 static inline int crypto_acomp_decompress(struct acomp_req *req)
 294 {
 295         struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
 296         int ret;
 297
 298         ret = tfm->decompress(req);
 299         crypto_stat_decompress(req, ret);
 300         return ret;
 301 }
 302
 303 #endif