[linux-block.git] / include / crypto / hash.h

/*
 * Hash: Hash algorithms under the crypto API
 * 
 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option) 
 * any later version.
 *
 */

#ifndef _CRYPTO_HASH_H
#define _CRYPTO_HASH_H

#include <linux/crypto.h>

struct crypto_ahash;

/**
 * DOC: Message Digest Algorithm Definitions
 *
 * These data structures define modular message digest algorithm
 * implementations, managed via crypto_register_ahash(),
 * crypto_register_shash(), crypto_unregister_ahash() and
 * crypto_unregister_shash().
 */

/**
 * struct hash_alg_common - define properties of message digest
 * @digestsize: Size of the result of the transformation. A buffer of this size
 *	        must be available to the @final and @finup calls, so they can
 *	        store the resulting hash into it. For various predefined sizes,
 *	        search include/crypto/ using
 *	        git grep _DIGEST_SIZE include/crypto.
 * @statesize: Size of the block for partial state of the transformation. A
 *	       buffer of this size must be passed to the @export function as it
 *	       will save the partial state of the transformation into it. On the
 *	       other side, the @import function will load the state from a
 *	       buffer of this size as well.
 */
struct hash_alg_common {
	unsigned int digestsize;
	unsigned int statesize;

	struct crypto_alg base;
};

struct ahash_request {
	struct crypto_async_request base;

	unsigned int nbytes;
	struct scatterlist *src;
	u8 *result;

	/* This field may only be used by the ahash API code. */
	void *priv;

	void *__ctx[] CRYPTO_MINALIGN_ATTR;
};

/**
 * struct ahash_alg - asynchronous message digest definition
 * @init: Initialize the transformation context. Intended only to initialize the
 *	  state of the HASH transformation at the begining. This shall fill in
 *	  the internal structures used during the entire duration of the whole
 *	  transformation. No data processing happens at this point.
 * @update: Push a chunk of data into the driver for transformation. This
 *	   function actually pushes blocks of data from upper layers into the
 *	   driver, which then passes those to the hardware as seen fit. This
 *	   function must not finalize the HASH transformation by calculating the
 *	   final message digest as this only adds more data into the
 *	   transformation. This function shall not modify the transformation
 *	   context, as this function may be called in parallel with the same
 *	   transformation object. Data processing can happen synchronously
 *	   [SHASH] or asynchronously [AHASH] at this point.
 * @final: Retrieve result from the driver. This function finalizes the
 *	   transformation and retrieves the resulting hash from the driver and
 *	   pushes it back to upper layers. No data processing happens at this
 *	   point.
 * @finup: Combination of @update and @final. This function is effectively a
 *	   combination of @update and @final calls issued in sequence. As some
 *	   hardware cannot do @update and @final separately, this callback was
 *	   added to allow such hardware to be used at least by IPsec. Data
 *	   processing can happen synchronously [SHASH] or asynchronously [AHASH]
 *	   at this point.
 * @digest: Combination of @init and @update and @final. This function
 *	    effectively behaves as the entire chain of operations, @init,
 *	    @update and @final issued in sequence. Just like @finup, this was
 *	    added for hardware which cannot do even the @finup, but can only do
 *	    the whole transformation in one run. Data processing can happen
 *	    synchronously [SHASH] or asynchronously [AHASH] at this point.
 * @setkey: Set optional key used by the hashing algorithm. Intended to push
 *	    optional key used by the hashing algorithm from upper layers into
 *	    the driver. This function can store the key in the transformation
 *	    context or can outright program it into the hardware. In the former
 *	    case, one must be careful to program the key into the hardware at
 *	    appropriate time and one must be careful that .setkey() can be
 *	    called multiple times during the existence of the transformation
 *	    object. Not  all hashing algorithms do implement this function as it
 *	    is only needed for keyed message digests. SHAx/MDx/CRCx do NOT
 *	    implement this function. HMAC(MDx)/HMAC(SHAx)/CMAC(AES) do implement
 *	    this function. This function must be called before any other of the
 *	    @init, @update, @final, @finup, @digest is called. No data
 *	    processing happens at this point.
 * @export: Export partial state of the transformation. This function dumps the
 *	    entire state of the ongoing transformation into a provided block of
 *	    data so it can be @import 'ed back later on. This is useful in case
 *	    you want to save partial result of the transformation after
 *	    processing certain amount of data and reload this partial result
 *	    multiple times later on for multiple re-use. No data processing
 *	    happens at this point.
 * @import: Import partial state of the transformation. This function loads the
 *	    entire state of the ongoing transformation from a provided block of
 *	    data so the transformation can continue from this point onward. No
 *	    data processing happens at this point.
 */
struct ahash_alg {
	int (*init)(struct ahash_request *req);
	int (*update)(struct ahash_request *req);
	int (*final)(struct ahash_request *req);
	int (*finup)(struct ahash_request *req);
	int (*digest)(struct ahash_request *req);
	int (*export)(struct ahash_request *req, void *out);
	int (*import)(struct ahash_request *req, const void *in);
	int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
		      unsigned int keylen);

	struct hash_alg_common halg;
};

struct shash_desc {
	struct crypto_shash *tfm;
	u32 flags;

	void *__ctx[] CRYPTO_MINALIGN_ATTR;
};

#define SHASH_DESC_ON_STACK(shash, ctx)				  \
	char __##shash##_desc[sizeof(struct shash_desc) +	  \
		crypto_shash_descsize(ctx)] CRYPTO_MINALIGN_ATTR; \
	struct shash_desc *shash = (struct shash_desc *)__##shash##_desc

/**
 * struct shash_alg - synchronous message digest definition
 * @init: see struct ahash_alg
 * @update: see struct ahash_alg
 * @final: see struct ahash_alg
 * @finup: see struct ahash_alg
 * @digest: see struct ahash_alg
 * @export: see struct ahash_alg
 * @import: see struct ahash_alg
 * @setkey: see struct ahash_alg
 * @digestsize: see struct ahash_alg
 * @statesize: see struct ahash_alg
 * @dedcsize: Size of the operational state for the message digest. This state
 * 	      size is the memory size that needs to be allocated for
 *	      shash_desc.__ctx
 * @base: internally used
 */
struct shash_alg {
	int (*init)(struct shash_desc *desc);
	int (*update)(struct shash_desc *desc, const u8 *data,
		      unsigned int len);
	int (*final)(struct shash_desc *desc, u8 *out);
	int (*finup)(struct shash_desc *desc, const u8 *data,
		     unsigned int len, u8 *out);
	int (*digest)(struct shash_desc *desc, const u8 *data,
		      unsigned int len, u8 *out);
	int (*export)(struct shash_desc *desc, void *out);
	int (*import)(struct shash_desc *desc, const void *in);
	int (*setkey)(struct crypto_shash *tfm, const u8 *key,
		      unsigned int keylen);

	unsigned int descsize;

	/* These fields must match hash_alg_common. */
	unsigned int digestsize
		__attribute__ ((aligned(__alignof__(struct hash_alg_common))));
	unsigned int statesize;

	struct crypto_alg base;
};

struct crypto_ahash {
	int (*init)(struct ahash_request *req);
	int (*update)(struct ahash_request *req);
	int (*final)(struct ahash_request *req);
	int (*finup)(struct ahash_request *req);
	int (*digest)(struct ahash_request *req);
	int (*export)(struct ahash_request *req, void *out);
	int (*import)(struct ahash_request *req, const void *in);
	int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
		      unsigned int keylen);

	unsigned int reqsize;
	struct crypto_tfm base;
};

struct crypto_shash {
	unsigned int descsize;
	struct crypto_tfm base;
};

static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
{
	return container_of(tfm, struct crypto_ahash, base);
}

struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
					u32 mask);

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

static inline void crypto_free_ahash(struct crypto_ahash *tfm)
{
	crypto_destroy_tfm(tfm, crypto_ahash_tfm(tfm));
}

static inline unsigned int crypto_ahash_alignmask(
	struct crypto_ahash *tfm)
{
	return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
}

static inline struct hash_alg_common *__crypto_hash_alg_common(
	struct crypto_alg *alg)
{
	return container_of(alg, struct hash_alg_common, base);
}

static inline struct hash_alg_common *crypto_hash_alg_common(
	struct crypto_ahash *tfm)
{
	return __crypto_hash_alg_common(crypto_ahash_tfm(tfm)->__crt_alg);
}

static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
{
	return crypto_hash_alg_common(tfm)->digestsize;
}

static inline unsigned int crypto_ahash_statesize(struct crypto_ahash *tfm)
{
	return crypto_hash_alg_common(tfm)->statesize;
}

static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
{
	return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
}

static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
{
	crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
}

static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
{
	crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
}

static inline struct crypto_ahash *crypto_ahash_reqtfm(
	struct ahash_request *req)
{
	return __crypto_ahash_cast(req->base.tfm);
}

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

static inline void *ahash_request_ctx(struct ahash_request *req)
{
	return req->__ctx;
}

int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
			unsigned int keylen);
int crypto_ahash_finup(struct ahash_request *req);
int crypto_ahash_final(struct ahash_request *req);
int crypto_ahash_digest(struct ahash_request *req);

static inline int crypto_ahash_export(struct ahash_request *req, void *out)
{
	return crypto_ahash_reqtfm(req)->export(req, out);
}

static inline int crypto_ahash_import(struct ahash_request *req, const void *in)
{
	return crypto_ahash_reqtfm(req)->import(req, in);
}

static inline int crypto_ahash_init(struct ahash_request *req)
{
	return crypto_ahash_reqtfm(req)->init(req);
}

static inline int crypto_ahash_update(struct ahash_request *req)
{
	return crypto_ahash_reqtfm(req)->update(req);
}

static inline void ahash_request_set_tfm(struct ahash_request *req,
					 struct crypto_ahash *tfm)
{
	req->base.tfm = crypto_ahash_tfm(tfm);
}

static inline struct ahash_request *ahash_request_alloc(
	struct crypto_ahash *tfm, gfp_t gfp)
{
	struct ahash_request *req;

	req = kmalloc(sizeof(struct ahash_request) +
		      crypto_ahash_reqsize(tfm), gfp);

	if (likely(req))
		ahash_request_set_tfm(req, tfm);

	return req;
}

static inline void ahash_request_free(struct ahash_request *req)
{
	kzfree(req);
}

static inline struct ahash_request *ahash_request_cast(
	struct crypto_async_request *req)
{
	return container_of(req, struct ahash_request, base);
}

static inline void ahash_request_set_callback(struct ahash_request *req,
					      u32 flags,
					      crypto_completion_t compl,
					      void *data)
{
	req->base.complete = compl;
	req->base.data = data;
	req->base.flags = flags;
}

static inline void ahash_request_set_crypt(struct ahash_request *req,
					   struct scatterlist *src, u8 *result,
					   unsigned int nbytes)
{
	req->src = src;
	req->nbytes = nbytes;
	req->result = result;
}

struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
					u32 mask);

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

static inline void crypto_free_shash(struct crypto_shash *tfm)
{
	crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
}

static inline unsigned int crypto_shash_alignmask(
	struct crypto_shash *tfm)
{
	return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
}

static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm)
{
	return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm));
}

static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
{
	return container_of(alg, struct shash_alg, base);
}

static inline struct shash_alg *crypto_shash_alg(struct crypto_shash *tfm)
{
	return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);
}

static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
{
	return crypto_shash_alg(tfm)->digestsize;
}

static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)
{
	return crypto_shash_alg(tfm)->statesize;
}

static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
{
	return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
}

static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)
{
	crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);
}

static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
{
	crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);
}

static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
{
	return tfm->descsize;
}

static inline void *shash_desc_ctx(struct shash_desc *desc)
{
	return desc->__ctx;
}

int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
			unsigned int keylen);
int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
			unsigned int len, u8 *out);

static inline int crypto_shash_export(struct shash_desc *desc, void *out)
{
	return crypto_shash_alg(desc->tfm)->export(desc, out);
}

static inline int crypto_shash_import(struct shash_desc *desc, const void *in)
{
	return crypto_shash_alg(desc->tfm)->import(desc, in);
}

static inline int crypto_shash_init(struct shash_desc *desc)
{
	return crypto_shash_alg(desc->tfm)->init(desc);
}

int crypto_shash_update(struct shash_desc *desc, const u8 *data,
			unsigned int len);
int crypto_shash_final(struct shash_desc *desc, u8 *out);
int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
		       unsigned int len, u8 *out);

#endif	/* _CRYPTO_HASH_H */
Commit	Line	Data
18e33e6d HX	1	/*
	2	* Hash: Hash algorithms under the crypto API
	3	*
	4	* Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the Free
	8	* Software Foundation; either version 2 of the License, or (at your option)
	9	* any later version.
	10	*
	11	*/
	12
	13	#ifndef _CRYPTO_HASH_H
	14	#define _CRYPTO_HASH_H
	15
	16	#include <linux/crypto.h>
	17
88056ec3 HX	18	struct crypto_ahash;
88056ec3 HX	19
5d8c723f SM	20	/**
	21	* DOC: Message Digest Algorithm Definitions
	22	*
	23	* These data structures define modular message digest algorithm
	24	* implementations, managed via crypto_register_ahash(),
	25	* crypto_register_shash(), crypto_unregister_ahash() and
	26	* crypto_unregister_shash().
	27	*/
	28
	29	/**
	30	* struct hash_alg_common - define properties of message digest
	31	* @digestsize: Size of the result of the transformation. A buffer of this size
	32	* must be available to the @final and @finup calls, so they can
	33	* store the resulting hash into it. For various predefined sizes,
	34	* search include/crypto/ using
	35	* git grep _DIGEST_SIZE include/crypto.
	36	* @statesize: Size of the block for partial state of the transformation. A
	37	* buffer of this size must be passed to the @export function as it
	38	* will save the partial state of the transformation into it. On the
	39	* other side, the @import function will load the state from a
	40	* buffer of this size as well.
	41	*/
88056ec3 HX	42	struct hash_alg_common {
	43	unsigned int digestsize;
	44	unsigned int statesize;
	45
	46	struct crypto_alg base;
	47	};
	48
	49	struct ahash_request {
	50	struct crypto_async_request base;
	51
	52	unsigned int nbytes;
	53	struct scatterlist *src;
	54	u8 *result;
	55
66f6ce5e HX	56	/* This field may only be used by the ahash API code. */
	57	void *priv;
	58
88056ec3 HX	59	void *__ctx[] CRYPTO_MINALIGN_ATTR;
	60	};
	61
5d8c723f SM	62	/**
	63	* struct ahash_alg - asynchronous message digest definition
	64	* @init: Initialize the transformation context. Intended only to initialize the
	65	* state of the HASH transformation at the begining. This shall fill in
	66	* the internal structures used during the entire duration of the whole
	67	* transformation. No data processing happens at this point.
	68	* @update: Push a chunk of data into the driver for transformation. This
	69	* function actually pushes blocks of data from upper layers into the
	70	* driver, which then passes those to the hardware as seen fit. This
	71	* function must not finalize the HASH transformation by calculating the
	72	* final message digest as this only adds more data into the
	73	* transformation. This function shall not modify the transformation
	74	* context, as this function may be called in parallel with the same
	75	* transformation object. Data processing can happen synchronously
	76	* [SHASH] or asynchronously [AHASH] at this point.
	77	* @final: Retrieve result from the driver. This function finalizes the
	78	* transformation and retrieves the resulting hash from the driver and
	79	* pushes it back to upper layers. No data processing happens at this
	80	* point.
	81	* @finup: Combination of @update and @final. This function is effectively a
	82	* combination of @update and @final calls issued in sequence. As some
	83	* hardware cannot do @update and @final separately, this callback was
	84	* added to allow such hardware to be used at least by IPsec. Data
	85	* processing can happen synchronously [SHASH] or asynchronously [AHASH]
	86	* at this point.
	87	* @digest: Combination of @init and @update and @final. This function
	88	* effectively behaves as the entire chain of operations, @init,
	89	* @update and @final issued in sequence. Just like @finup, this was
	90	* added for hardware which cannot do even the @finup, but can only do
	91	* the whole transformation in one run. Data processing can happen
	92	* synchronously [SHASH] or asynchronously [AHASH] at this point.
	93	* @setkey: Set optional key used by the hashing algorithm. Intended to push
	94	* optional key used by the hashing algorithm from upper layers into
	95	* the driver. This function can store the key in the transformation
	96	* context or can outright program it into the hardware. In the former
	97	* case, one must be careful to program the key into the hardware at
	98	* appropriate time and one must be careful that .setkey() can be
	99	* called multiple times during the existence of the transformation
	100	* object. Not all hashing algorithms do implement this function as it
	101	* is only needed for keyed message digests. SHAx/MDx/CRCx do NOT
	102	* implement this function. HMAC(MDx)/HMAC(SHAx)/CMAC(AES) do implement
	103	* this function. This function must be called before any other of the
	104	* @init, @update, @final, @finup, @digest is called. No data
	105	* processing happens at this point.
	106	* @export: Export partial state of the transformation. This function dumps the
	107	* entire state of the ongoing transformation into a provided block of
	108	* data so it can be @import 'ed back later on. This is useful in case
	109	* you want to save partial result of the transformation after
	110	* processing certain amount of data and reload this partial result
	111	* multiple times later on for multiple re-use. No data processing
	112	* happens at this point.
	113	* @import: Import partial state of the transformation. This function loads the
	114	* entire state of the ongoing transformation from a provided block of
	115	* data so the transformation can continue from this point onward. No
	116	* data processing happens at this point.
	117	*/
88056ec3 HX	118	struct ahash_alg {
	119	int (init)(struct ahash_request req);
	120	int (update)(struct ahash_request req);
	121	int (final)(struct ahash_request req);
	122	int (finup)(struct ahash_request req);
	123	int (digest)(struct ahash_request req);
	124	int (export)(struct ahash_request req, void *out);
	125	int (import)(struct ahash_request req, const void *in);
	126	int (setkey)(struct crypto_ahash tfm, const u8 *key,
	127	unsigned int keylen);
	128
	129	struct hash_alg_common halg;
	130	};
	131
7b5a080b HX	132	struct shash_desc {
	133	struct crypto_shash *tfm;
	134	u32 flags;
	135
	136	void *__ctx[] CRYPTO_MINALIGN_ATTR;
	137	};
	138
a0a77af1 BW	139	#define SHASH_DESC_ON_STACK(shash, ctx) \
	140	char __##shash##_desc[sizeof(struct shash_desc) + \
	141	crypto_shash_descsize(ctx)] CRYPTO_MINALIGN_ATTR; \
	142	struct shash_desc shash = (struct shash_desc )__##shash##_desc
	143
5d8c723f SM	144	/**
	145	* struct shash_alg - synchronous message digest definition
	146	* @init: see struct ahash_alg
	147	* @update: see struct ahash_alg
	148	* @final: see struct ahash_alg
	149	* @finup: see struct ahash_alg
	150	* @digest: see struct ahash_alg
	151	* @export: see struct ahash_alg
	152	* @import: see struct ahash_alg
	153	* @setkey: see struct ahash_alg
	154	* @digestsize: see struct ahash_alg
	155	* @statesize: see struct ahash_alg
	156	* @dedcsize: Size of the operational state for the message digest. This state
	157	* size is the memory size that needs to be allocated for
	158	* shash_desc.__ctx
	159	* @base: internally used
	160	*/
7b5a080b HX	161	struct shash_alg {
	162	int (init)(struct shash_desc desc);
	163	int (update)(struct shash_desc desc, const u8 *data,
	164	unsigned int len);
	165	int (final)(struct shash_desc desc, u8 *out);
	166	int (finup)(struct shash_desc desc, const u8 *data,
	167	unsigned int len, u8 *out);
	168	int (digest)(struct shash_desc desc, const u8 *data,
	169	unsigned int len, u8 *out);
99d27e1c HX	170	int (export)(struct shash_desc desc, void *out);
99d27e1c HX	171	int (import)(struct shash_desc desc, const void *in);
7b5a080b HX	172	int (setkey)(struct crypto_shash tfm, const u8 *key,
	173	unsigned int keylen);
	174
	175	unsigned int descsize;
88056ec3 HX	176
88056ec3 HX	177	/* These fields must match hash_alg_common. */
fa649664 HX	178	unsigned int digestsize
fa649664 HX	179	__attribute__ ((aligned(__alignof__(struct hash_alg_common))));
99d27e1c	180	unsigned int statesize;
7b5a080b HX	181
	182	struct crypto_alg base;
	183	};
	184
18e33e6d	185	struct crypto_ahash {
88056ec3 HX	186	int (init)(struct ahash_request req);
	187	int (update)(struct ahash_request req);
	188	int (final)(struct ahash_request req);
	189	int (finup)(struct ahash_request req);
	190	int (digest)(struct ahash_request req);
	191	int (export)(struct ahash_request req, void *out);
	192	int (import)(struct ahash_request req, const void *in);
	193	int (setkey)(struct crypto_ahash tfm, const u8 *key,
	194	unsigned int keylen);
	195
88056ec3	196	unsigned int reqsize;
18e33e6d HX	197	struct crypto_tfm base;
	198	};
	199
7b5a080b	200	struct crypto_shash {
113adefc	201	unsigned int descsize;
7b5a080b HX	202	struct crypto_tfm base;
	203	};
	204
18e33e6d HX	205	static inline struct crypto_ahash __crypto_ahash_cast(struct crypto_tfm tfm)
18e33e6d HX	206	{
88056ec3	207	return container_of(tfm, struct crypto_ahash, base);
18e33e6d HX	208	}
18e33e6d HX	209
88056ec3 HX	210	struct crypto_ahash crypto_alloc_ahash(const char alg_name, u32 type,
88056ec3 HX	211	u32 mask);
18e33e6d HX	212
	213	static inline struct crypto_tfm crypto_ahash_tfm(struct crypto_ahash tfm)
	214	{
	215	return &tfm->base;
	216	}
	217
	218	static inline void crypto_free_ahash(struct crypto_ahash *tfm)
	219	{
88056ec3	220	crypto_destroy_tfm(tfm, crypto_ahash_tfm(tfm));
18e33e6d HX	221	}
	222
	223	static inline unsigned int crypto_ahash_alignmask(
	224	struct crypto_ahash *tfm)
	225	{
	226	return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
	227	}
	228
88056ec3 HX	229	static inline struct hash_alg_common *__crypto_hash_alg_common(
	230	struct crypto_alg *alg)
	231	{
	232	return container_of(alg, struct hash_alg_common, base);
	233	}
	234
	235	static inline struct hash_alg_common *crypto_hash_alg_common(
	236	struct crypto_ahash *tfm)
18e33e6d	237	{
88056ec3	238	return __crypto_hash_alg_common(crypto_ahash_tfm(tfm)->__crt_alg);
18e33e6d HX	239	}
	240
	241	static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
	242	{
500b3e3c	243	return crypto_hash_alg_common(tfm)->digestsize;
88056ec3 HX	244	}
	245
	246	static inline unsigned int crypto_ahash_statesize(struct crypto_ahash *tfm)
	247	{
	248	return crypto_hash_alg_common(tfm)->statesize;
18e33e6d HX	249	}
	250
	251	static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
	252	{
	253	return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
	254	}
	255
	256	static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
	257	{
	258	crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
	259	}
	260
	261	static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
	262	{
	263	crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
	264	}
	265
	266	static inline struct crypto_ahash *crypto_ahash_reqtfm(
	267	struct ahash_request *req)
	268	{
	269	return __crypto_ahash_cast(req->base.tfm);
	270	}
	271
	272	static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
	273	{
88056ec3	274	return tfm->reqsize;
18e33e6d HX	275	}
18e33e6d HX	276
dec8b786 HX	277	static inline void ahash_request_ctx(struct ahash_request req)
	278	{
	279	return req->__ctx;
	280	}
	281
66f6ce5e HX	282	int crypto_ahash_setkey(struct crypto_ahash tfm, const u8 key,
	283	unsigned int keylen);
	284	int crypto_ahash_finup(struct ahash_request *req);
	285	int crypto_ahash_final(struct ahash_request *req);
	286	int crypto_ahash_digest(struct ahash_request *req);
18e33e6d	287
88056ec3	288	static inline int crypto_ahash_export(struct ahash_request req, void out)
dec8b786	289	{
88056ec3	290	return crypto_ahash_reqtfm(req)->export(req, out);
dec8b786 HX	291	}
dec8b786 HX	292
88056ec3 HX	293	static inline int crypto_ahash_import(struct ahash_request req, const void in)
	294	{
	295	return crypto_ahash_reqtfm(req)->import(req, in);
	296	}
dec8b786	297
318e5313 HX	298	static inline int crypto_ahash_init(struct ahash_request *req)
318e5313 HX	299	{
88056ec3	300	return crypto_ahash_reqtfm(req)->init(req);
318e5313 HX	301	}
	302
	303	static inline int crypto_ahash_update(struct ahash_request *req)
	304	{
88056ec3	305	return crypto_ahash_reqtfm(req)->update(req);
318e5313 HX	306	}
318e5313 HX	307
18e33e6d HX	308	static inline void ahash_request_set_tfm(struct ahash_request *req,
	309	struct crypto_ahash *tfm)
	310	{
	311	req->base.tfm = crypto_ahash_tfm(tfm);
	312	}
	313
	314	static inline struct ahash_request *ahash_request_alloc(
	315	struct crypto_ahash *tfm, gfp_t gfp)
	316	{
	317	struct ahash_request *req;
	318
	319	req = kmalloc(sizeof(struct ahash_request) +
	320	crypto_ahash_reqsize(tfm), gfp);
	321
	322	if (likely(req))
	323	ahash_request_set_tfm(req, tfm);
	324
	325	return req;
	326	}
	327
	328	static inline void ahash_request_free(struct ahash_request *req)
	329	{
aef73cfc	330	kzfree(req);
18e33e6d HX	331	}
	332
	333	static inline struct ahash_request *ahash_request_cast(
	334	struct crypto_async_request *req)
	335	{
	336	return container_of(req, struct ahash_request, base);
	337	}
	338
	339	static inline void ahash_request_set_callback(struct ahash_request *req,
	340	u32 flags,
3e3dc25f	341	crypto_completion_t compl,
18e33e6d HX	342	void *data)
18e33e6d HX	343	{
3e3dc25f	344	req->base.complete = compl;
18e33e6d HX	345	req->base.data = data;
	346	req->base.flags = flags;
	347	}
	348
	349	static inline void ahash_request_set_crypt(struct ahash_request *req,
	350	struct scatterlist src, u8 result,
	351	unsigned int nbytes)
	352	{
	353	req->src = src;
	354	req->nbytes = nbytes;
	355	req->result = result;
	356	}
	357
7b5a080b HX	358	struct crypto_shash crypto_alloc_shash(const char alg_name, u32 type,
	359	u32 mask);
	360
	361	static inline struct crypto_tfm crypto_shash_tfm(struct crypto_shash tfm)
	362	{
	363	return &tfm->base;
	364	}
	365
	366	static inline void crypto_free_shash(struct crypto_shash *tfm)
	367	{
412e87ae	368	crypto_destroy_tfm(tfm, crypto_shash_tfm(tfm));
7b5a080b HX	369	}
	370
	371	static inline unsigned int crypto_shash_alignmask(
	372	struct crypto_shash *tfm)
	373	{
	374	return crypto_tfm_alg_alignmask(crypto_shash_tfm(tfm));
	375	}
	376
97495986 HX	377	static inline unsigned int crypto_shash_blocksize(struct crypto_shash *tfm)
	378	{
	379	return crypto_tfm_alg_blocksize(crypto_shash_tfm(tfm));
	380	}
	381
7b5a080b HX	382	static inline struct shash_alg __crypto_shash_alg(struct crypto_alg alg)
	383	{
	384	return container_of(alg, struct shash_alg, base);
	385	}
	386
	387	static inline struct shash_alg crypto_shash_alg(struct crypto_shash tfm)
	388	{
	389	return __crypto_shash_alg(crypto_shash_tfm(tfm)->__crt_alg);
	390	}
	391
	392	static inline unsigned int crypto_shash_digestsize(struct crypto_shash *tfm)
	393	{
	394	return crypto_shash_alg(tfm)->digestsize;
	395	}
	396
99d27e1c HX	397	static inline unsigned int crypto_shash_statesize(struct crypto_shash *tfm)
	398	{
	399	return crypto_shash_alg(tfm)->statesize;
	400	}
	401
7b5a080b HX	402	static inline u32 crypto_shash_get_flags(struct crypto_shash *tfm)
	403	{
	404	return crypto_tfm_get_flags(crypto_shash_tfm(tfm));
	405	}
	406
	407	static inline void crypto_shash_set_flags(struct crypto_shash *tfm, u32 flags)
	408	{
	409	crypto_tfm_set_flags(crypto_shash_tfm(tfm), flags);
	410	}
	411
	412	static inline void crypto_shash_clear_flags(struct crypto_shash *tfm, u32 flags)
	413	{
	414	crypto_tfm_clear_flags(crypto_shash_tfm(tfm), flags);
	415	}
	416
	417	static inline unsigned int crypto_shash_descsize(struct crypto_shash *tfm)
	418	{
113adefc	419	return tfm->descsize;
7b5a080b HX	420	}
	421
	422	static inline void shash_desc_ctx(struct shash_desc desc)
	423	{
	424	return desc->__ctx;
	425	}
	426
	427	int crypto_shash_setkey(struct crypto_shash tfm, const u8 key,
	428	unsigned int keylen);
	429	int crypto_shash_digest(struct shash_desc desc, const u8 data,
	430	unsigned int len, u8 *out);
	431
99d27e1c	432	static inline int crypto_shash_export(struct shash_desc desc, void out)
dec8b786	433	{
99d27e1c	434	return crypto_shash_alg(desc->tfm)->export(desc, out);
dec8b786 HX	435	}
dec8b786 HX	436
99d27e1c HX	437	static inline int crypto_shash_import(struct shash_desc desc, const void in)
	438	{
	439	return crypto_shash_alg(desc->tfm)->import(desc, in);
	440	}
dec8b786	441
7b5a080b HX	442	static inline int crypto_shash_init(struct shash_desc *desc)
	443	{
	444	return crypto_shash_alg(desc->tfm)->init(desc);
	445	}
	446
	447	int crypto_shash_update(struct shash_desc desc, const u8 data,
	448	unsigned int len);
	449	int crypto_shash_final(struct shash_desc desc, u8 out);
	450	int crypto_shash_finup(struct shash_desc desc, const u8 data,
	451	unsigned int len, u8 *out);
	452
18e33e6d	453	#endif /* _CRYPTO_HASH_H */