root/include/crypto/internal/scompress.h

INCLUDED FROM

DEFINITIONS

1. __crypto_scomp_alg
2. __crypto_scomp_tfm
3. crypto_scomp_tfm
4. crypto_free_scomp
5. crypto_scomp_alg
6. crypto_scomp_alloc_ctx
7. crypto_scomp_free_ctx
8. crypto_scomp_compress
9. crypto_scomp_decompress

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * Synchronous Compression operations
   4  *
   5  * Copyright 2015 LG Electronics Inc.
   6  * Copyright (c) 2016, Intel Corporation
   7  * Author: Giovanni Cabiddu <giovanni.cabiddu@intel.com>
   8  */
   9 #ifndef _CRYPTO_SCOMP_INT_H
  10 #define _CRYPTO_SCOMP_INT_H
  11 #include <linux/crypto.h>
  12 
  13 #define SCOMP_SCRATCH_SIZE      131072
  14 
  15 struct crypto_scomp {
  16         struct crypto_tfm base;
  17 };
  18 
  19 /**
  20  * struct scomp_alg - synchronous compression algorithm
  21  *
  22  * @alloc_ctx:  Function allocates algorithm specific context
  23  * @free_ctx:   Function frees context allocated with alloc_ctx
  24  * @compress:   Function performs a compress operation
  25  * @decompress: Function performs a de-compress operation
  26  * @base:       Common crypto API algorithm data structure
  27  */
  28 struct scomp_alg {
  29         void *(*alloc_ctx)(struct crypto_scomp *tfm);
  30         void (*free_ctx)(struct crypto_scomp *tfm, void *ctx);
  31         int (*compress)(struct crypto_scomp *tfm, const u8 *src,
  32                         unsigned int slen, u8 *dst, unsigned int *dlen,
  33                         void *ctx);
  34         int (*decompress)(struct crypto_scomp *tfm, const u8 *src,
  35                           unsigned int slen, u8 *dst, unsigned int *dlen,
  36                           void *ctx);
  37         struct crypto_alg base;
  38 };
  39 
  40 static inline struct scomp_alg *__crypto_scomp_alg(struct crypto_alg *alg)
  41 {
  42         return container_of(alg, struct scomp_alg, base);
  43 }
  44 
  45 static inline struct crypto_scomp *__crypto_scomp_tfm(struct crypto_tfm *tfm)
  46 {
  47         return container_of(tfm, struct crypto_scomp, base);
  48 }
  49 
  50 static inline struct crypto_tfm *crypto_scomp_tfm(struct crypto_scomp *tfm)
  51 {
  52         return &tfm->base;
  53 }
  54 
  55 static inline void crypto_free_scomp(struct crypto_scomp *tfm)
  56 {
  57         crypto_destroy_tfm(tfm, crypto_scomp_tfm(tfm));
  58 }
  59 
  60 static inline struct scomp_alg *crypto_scomp_alg(struct crypto_scomp *tfm)
  61 {
  62         return __crypto_scomp_alg(crypto_scomp_tfm(tfm)->__crt_alg);
  63 }
  64 
  65 static inline void *crypto_scomp_alloc_ctx(struct crypto_scomp *tfm)
  66 {
  67         return crypto_scomp_alg(tfm)->alloc_ctx(tfm);
  68 }
  69 
  70 static inline void crypto_scomp_free_ctx(struct crypto_scomp *tfm,
  71                                          void *ctx)
  72 {
  73         return crypto_scomp_alg(tfm)->free_ctx(tfm, ctx);
  74 }
  75 
  76 static inline int crypto_scomp_compress(struct crypto_scomp *tfm,
  77                                         const u8 *src, unsigned int slen,
  78                                         u8 *dst, unsigned int *dlen, void *ctx)
  79 {
  80         return crypto_scomp_alg(tfm)->compress(tfm, src, slen, dst, dlen, ctx);
  81 }
  82 
  83 static inline int crypto_scomp_decompress(struct crypto_scomp *tfm,
  84                                           const u8 *src, unsigned int slen,
  85                                           u8 *dst, unsigned int *dlen,
  86                                           void *ctx)
  87 {
  88         return crypto_scomp_alg(tfm)->decompress(tfm, src, slen, dst, dlen,
  89                                                  ctx);
  90 }
  91 
  92 int crypto_init_scomp_ops_async(struct crypto_tfm *tfm);
  93 struct acomp_req *crypto_acomp_scomp_alloc_ctx(struct acomp_req *req);
  94 void crypto_acomp_scomp_free_ctx(struct acomp_req *req);
  95 
  96 /**
  97  * crypto_register_scomp() -- Register synchronous compression algorithm
  98  *
  99  * Function registers an implementation of a synchronous
 100  * compression algorithm
 101  *
 102  * @alg:        algorithm definition
 103  *
 104  * Return: zero on success; error code in case of error
 105  */
 106 int crypto_register_scomp(struct scomp_alg *alg);
 107 
 108 /**
 109  * crypto_unregister_scomp() -- Unregister synchronous compression algorithm
 110  *
 111  * Function unregisters an implementation of a synchronous
 112  * compression algorithm
 113  *
 114  * @alg:        algorithm definition
 115  *
 116  * Return: zero on success; error code in case of error
 117  */
 118 int crypto_unregister_scomp(struct scomp_alg *alg);
 119 
 120 int crypto_register_scomps(struct scomp_alg *algs, int count);
 121 void crypto_unregister_scomps(struct scomp_alg *algs, int count);
 122 
 123 #endif