[mirror_ubuntu-hirsute-kernel.git] / include / crypto / acompress.h

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Asynchronous Compression operations
 *
 * Copyright (c) 2016, Intel Corporation
 * Authors: Weigang Li <weigang.li@intel.com>
 *          Giovanni Cabiddu <giovanni.cabiddu@intel.com>
 */
#ifndef _CRYPTO_ACOMP_H
#define _CRYPTO_ACOMP_H
#include <linux/crypto.h>

#define CRYPTO_ACOMP_ALLOC_OUTPUT	0x00000001

/**
 * struct acomp_req - asynchronous (de)compression request
 *
 * @base:	Common attributes for asynchronous crypto requests
 * @src:	Source Data
 * @dst:	Destination data
 * @slen:	Size of the input buffer
 * @dlen:	Size of the output buffer and number of bytes produced
 * @flags:	Internal flags
 * @__ctx:	Start of private context data
 */
struct acomp_req {
	struct crypto_async_request base;
	struct scatterlist *src;
	struct scatterlist *dst;
	unsigned int slen;
	unsigned int dlen;
	u32 flags;
	void *__ctx[] CRYPTO_MINALIGN_ATTR;
};

/**
 * struct crypto_acomp - user-instantiated objects which encapsulate
 * algorithms and core processing logic
 *
 * @compress:		Function performs a compress operation
 * @decompress:		Function performs a de-compress operation
 * @dst_free:		Frees destination buffer if allocated inside the
 *			algorithm
 * @reqsize:		Context size for (de)compression requests
 * @base:		Common crypto API algorithm data structure
 */
struct crypto_acomp {
	int (*compress)(struct acomp_req *req);
	int (*decompress)(struct acomp_req *req);
	void (*dst_free)(struct scatterlist *dst);
	unsigned int reqsize;
	struct crypto_tfm base;
};

/**
 * struct acomp_alg - asynchronous compression algorithm
 *
 * @compress:	Function performs a compress operation
 * @decompress:	Function performs a de-compress operation
 * @dst_free:	Frees destination buffer if allocated inside the algorithm
 * @init:	Initialize the cryptographic transformation object.
 *		This function is used to initialize the cryptographic
 *		transformation object. This function is called only once at
 *		the instantiation time, right after the transformation context
 *		was allocated. In case the cryptographic hardware has some
 *		special requirements which need to be handled by software, this
 *		function shall check for the precise requirement of the
 *		transformation and put any software fallbacks in place.
 * @exit:	Deinitialize the cryptographic transformation object. This is a
 *		counterpart to @init, used to remove various changes set in
 *		@init.
 *
 * @reqsize:	Context size for (de)compression requests
 * @base:	Common crypto API algorithm data structure
 */
struct acomp_alg {
	int (*compress)(struct acomp_req *req);
	int (*decompress)(struct acomp_req *req);
	void (*dst_free)(struct scatterlist *dst);
	int (*init)(struct crypto_acomp *tfm);
	void (*exit)(struct crypto_acomp *tfm);
	unsigned int reqsize;
	struct crypto_alg base;
};

/**
 * DOC: Asynchronous Compression API
 *
 * The Asynchronous Compression API is used with the algorithms of type
 * CRYPTO_ALG_TYPE_ACOMPRESS (listed as type "acomp" in /proc/crypto)
 */

/**
 * crypto_alloc_acomp() -- allocate ACOMPRESS tfm handle
 * @alg_name:	is the cra_name / name or cra_driver_name / driver name of the
 *		compression algorithm e.g. "deflate"
 * @type:	specifies the type of the algorithm
 * @mask:	specifies the mask for the algorithm
 *
 * Allocate a handle for a compression algorithm. The returned struct
 * crypto_acomp is the handle that is required for any subsequent
 * API invocation for the compression operations.
 *
 * Return:	allocated handle in case of success; IS_ERR() is true in case
 *		of an error, PTR_ERR() returns the error code.
 */
struct crypto_acomp *crypto_alloc_acomp(const char *alg_name, u32 type,
					u32 mask);

static inline struct crypto_tfm *crypto_acomp_tfm(struct crypto_acomp *tfm)
{
	return &tfm->base;
}

static inline struct acomp_alg *__crypto_acomp_alg(struct crypto_alg *alg)
{
	return container_of(alg, struct acomp_alg, base);
}

static inline struct crypto_acomp *__crypto_acomp_tfm(struct crypto_tfm *tfm)
{
	return container_of(tfm, struct crypto_acomp, base);
}

static inline struct acomp_alg *crypto_acomp_alg(struct crypto_acomp *tfm)
{
	return __crypto_acomp_alg(crypto_acomp_tfm(tfm)->__crt_alg);
}

static inline unsigned int crypto_acomp_reqsize(struct crypto_acomp *tfm)
{
	return tfm->reqsize;
}

static inline void acomp_request_set_tfm(struct acomp_req *req,
					 struct crypto_acomp *tfm)
{
	req->base.tfm = crypto_acomp_tfm(tfm);
}

static inline struct crypto_acomp *crypto_acomp_reqtfm(struct acomp_req *req)
{
	return __crypto_acomp_tfm(req->base.tfm);
}

/**
 * crypto_free_acomp() -- free ACOMPRESS tfm handle
 *
 * @tfm:	ACOMPRESS tfm handle allocated with crypto_alloc_acomp()
 */
static inline void crypto_free_acomp(struct crypto_acomp *tfm)
{
	crypto_destroy_tfm(tfm, crypto_acomp_tfm(tfm));
}

static inline int crypto_has_acomp(const char *alg_name, u32 type, u32 mask)
{
	type &= ~CRYPTO_ALG_TYPE_MASK;
	type |= CRYPTO_ALG_TYPE_ACOMPRESS;
	mask |= CRYPTO_ALG_TYPE_MASK;

	return crypto_has_alg(alg_name, type, mask);
}

/**
 * acomp_request_alloc() -- allocates asynchronous (de)compression request
 *
 * @tfm:	ACOMPRESS tfm handle allocated with crypto_alloc_acomp()
 *
 * Return:	allocated handle in case of success or NULL in case of an error
 */
struct acomp_req *acomp_request_alloc(struct crypto_acomp *tfm);

/**
 * acomp_request_free() -- zeroize and free asynchronous (de)compression
 *			   request as well as the output buffer if allocated
 *			   inside the algorithm
 *
 * @req:	request to free
 */
void acomp_request_free(struct acomp_req *req);

/**
 * acomp_request_set_callback() -- Sets an asynchronous callback
 *
 * Callback will be called when an asynchronous operation on a given
 * request is finished.
 *
 * @req:	request that the callback will be set for
 * @flgs:	specify for instance if the operation may backlog
 * @cmlp:	callback which will be called
 * @data:	private data used by the caller
 */
static inline void acomp_request_set_callback(struct acomp_req *req,
					      u32 flgs,
					      crypto_completion_t cmpl,
					      void *data)
{
	req->base.complete = cmpl;
	req->base.data = data;
	req->base.flags = flgs;
}

/**
 * acomp_request_set_params() -- Sets request parameters
 *
 * Sets parameters required by an acomp operation
 *
 * @req:	asynchronous compress request
 * @src:	pointer to input buffer scatterlist
 * @dst:	pointer to output buffer scatterlist. If this is NULL, the
 *		acomp layer will allocate the output memory
 * @slen:	size of the input buffer
 * @dlen:	size of the output buffer. If dst is NULL, this can be used by
 *		the user to specify the maximum amount of memory to allocate
 */
static inline void acomp_request_set_params(struct acomp_req *req,
					    struct scatterlist *src,
					    struct scatterlist *dst,
					    unsigned int slen,
					    unsigned int dlen)
{
	req->src = src;
	req->dst = dst;
	req->slen = slen;
	req->dlen = dlen;

	if (!req->dst)
		req->flags |= CRYPTO_ACOMP_ALLOC_OUTPUT;
}

/**
 * crypto_acomp_compress() -- Invoke asynchronous compress operation
 *
 * Function invokes the asynchronous compress operation
 *
 * @req:	asynchronous compress request
 *
 * Return:	zero on success; error code in case of error
 */
static inline int crypto_acomp_compress(struct acomp_req *req)
{
	struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
	struct crypto_alg *alg = tfm->base.__crt_alg;
	unsigned int slen = req->slen;
	int ret;

	crypto_stats_get(alg);
	ret = tfm->compress(req);
	crypto_stats_compress(slen, ret, alg);
	return ret;
}

/**
 * crypto_acomp_decompress() -- Invoke asynchronous decompress operation
 *
 * Function invokes the asynchronous decompress operation
 *
 * @req:	asynchronous compress request
 *
 * Return:	zero on success; error code in case of error
 */
static inline int crypto_acomp_decompress(struct acomp_req *req)
{
	struct crypto_acomp *tfm = crypto_acomp_reqtfm(req);
	struct crypto_alg *alg = tfm->base.__crt_alg;
	unsigned int slen = req->slen;
	int ret;

	crypto_stats_get(alg);
	ret = tfm->decompress(req);
	crypto_stats_decompress(slen, ret, alg);
	return ret;
}

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