crypto: hash - Move ahash functions into crypto/hash.h

All new crypto interfaces should go into individual files as much as possible in order to ensure that crypto.h does not collapse under its own weight. This patch moves the ahash code into crypto/hash.h and crypto/internal/hash.h respectively. Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

crypto: hash - Move ahash functions into crypto/hash.h
All new crypto interfaces should go into individual files as much as possible in order to ensure that crypto.h does not collapse under its own weight. This patch moves the ahash code into crypto/hash.h and crypto/internal/hash.h respectively. Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Herbert Xu
1 parent 5773a3e6e3
Showing 8 changed files with 195 additions and 172 deletions Side-by-side Diff
crypto/cryptd.c
crypto/digest.c
crypto/hash.c
crypto/tcrypt.c
include/crypto/algapi.h
include/crypto/hash.h
include/crypto/internal/hash.h
include/linux/crypto.h
@@ -11,6 +11,7 @@
  */
  
 #include <crypto/algapi.h>
+#include <crypto/internal/hash.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
@@ -12,6 +12,7 @@
  *
  */
  
+#include <crypto/internal/hash.h>
 #include <crypto/scatterwalk.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
@@ -9,6 +9,7 @@
  * any later version.
  */
  
+#include <crypto/internal/hash.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -15,6 +15,7 @@
  *
  */
  
+#include <crypto/hash.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/module.h>
@@ -98,7 +98,6 @@
 extern const struct crypto_type crypto_aead_type;
 extern const struct crypto_type crypto_blkcipher_type;
 extern const struct crypto_type crypto_hash_type;
-extern const struct crypto_type crypto_ahash_type;
  
 void crypto_mod_put(struct crypto_alg *alg);
  
@@ -314,41 +313,6 @@
 {
 	return (type ^ CRYPTO_ALG_ASYNC) & mask & CRYPTO_ALG_ASYNC;
 }
-
-static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
-{
-	return crypto_tfm_ctx(&tfm->base);
-}
-
-static inline struct ahash_alg *crypto_ahash_alg(
-	struct crypto_ahash *tfm)
-{
-	return &crypto_ahash_tfm(tfm)->__crt_alg->cra_ahash;
-}
-
-static inline int ahash_enqueue_request(struct crypto_queue *queue,
-					     struct ahash_request *request)
-{
-	return crypto_enqueue_request(queue, &request->base);
-}
-
-static inline struct ahash_request *ahash_dequeue_request(
-	struct crypto_queue *queue)
-{
-	return ahash_request_cast(crypto_dequeue_request(queue));
-}
-
-static inline void *ahash_request_ctx(struct ahash_request *req)
-{
-	return req->__ctx;
-}
-
-static inline int ahash_tfm_in_queue(struct crypto_queue *queue,
-					  struct crypto_ahash *tfm)
-{
-	return crypto_tfm_in_queue(queue, crypto_ahash_tfm(tfm));
-}
-
  
 #endif	/* _CRYPTO_ALGAPI_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 {
+	struct crypto_tfm base;
+};
+
+static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
+{
+	return (struct crypto_ahash *)tfm;
+}
+
+static inline struct crypto_ahash *crypto_alloc_ahash(const char *alg_name,
+						      u32 type, u32 mask)
+{
+	type &= ~CRYPTO_ALG_TYPE_MASK;
+	mask &= ~CRYPTO_ALG_TYPE_MASK;
+	type |= CRYPTO_ALG_TYPE_AHASH;
+	mask |= CRYPTO_ALG_TYPE_AHASH_MASK;
+
+	return __crypto_ahash_cast(crypto_alloc_base(alg_name, type, 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_free_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 ahash_tfm *crypto_ahash_crt(struct crypto_ahash *tfm)
+{
+	return &crypto_ahash_tfm(tfm)->crt_ahash;
+}
+
+static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
+{
+	return crypto_ahash_crt(tfm)->digestsize;
+}
+
+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 crypto_ahash_crt(tfm)->reqsize;
+}
+
+static inline int crypto_ahash_setkey(struct crypto_ahash *tfm,
+				      const u8 *key, unsigned int keylen)
+{
+	struct ahash_tfm *crt = crypto_ahash_crt(tfm);
+
+	return crt->setkey(tfm, key, keylen);
+}
+
+static inline int crypto_ahash_digest(struct ahash_request *req)
+{
+	struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
+	return crt->digest(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)
+{
+	kfree(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 complete,
+					      void *data)
+{
+	req->base.complete = complete;
+	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;
+}
+
+#endif	/* _CRYPTO_HASH_H */
@@ -14,6 +14,7 @@
 #define _CRYPTO_INTERNAL_HASH_H
  
 #include <crypto/algapi.h>
+#include <crypto/hash.h>
  
 struct ahash_request;
 struct scatterlist;
  
@@ -33,9 +34,45 @@
 	unsigned int flags;
 };
  
+extern const struct crypto_type crypto_ahash_type;
+
 int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
 int crypto_hash_walk_first(struct ahash_request *req,
 			   struct crypto_hash_walk *walk);
+
+static inline void *crypto_ahash_ctx(struct crypto_ahash *tfm)
+{
+	return crypto_tfm_ctx(&tfm->base);
+}
+
+static inline struct ahash_alg *crypto_ahash_alg(
+	struct crypto_ahash *tfm)
+{
+	return &crypto_ahash_tfm(tfm)->__crt_alg->cra_ahash;
+}
+
+static inline int ahash_enqueue_request(struct crypto_queue *queue,
+					     struct ahash_request *request)
+{
+	return crypto_enqueue_request(queue, &request->base);
+}
+
+static inline struct ahash_request *ahash_dequeue_request(
+	struct crypto_queue *queue)
+{
+	return ahash_request_cast(crypto_dequeue_request(queue));
+}
+
+static inline void *ahash_request_ctx(struct ahash_request *req)
+{
+	return req->__ctx;
+}
+
+static inline int ahash_tfm_in_queue(struct crypto_queue *queue,
+					  struct crypto_ahash *tfm)
+{
+	return crypto_tfm_in_queue(queue, crypto_ahash_tfm(tfm));
+}
  
 #endif	/* _CRYPTO_INTERNAL_HASH_H */
@@ -481,10 +481,6 @@
 	struct crypto_tfm base;
 };
  
-struct crypto_ahash {
-	struct crypto_tfm base;
-};
-
 enum {
 	CRYPTOA_UNSPEC,
 	CRYPTOA_ALG,
@@ -1306,138 +1302,6 @@
 {
 	return crypto_comp_crt(tfm)->cot_decompress(crypto_comp_tfm(tfm),
 						    src, slen, dst, dlen);
-}
-
-static inline struct crypto_ahash *__crypto_ahash_cast(struct crypto_tfm *tfm)
-{
-	return (struct crypto_ahash *)tfm;
-}
-
-static inline struct crypto_ahash *crypto_alloc_ahash(const char *alg_name,
-						      u32 type, u32 mask)
-{
-	type &= ~CRYPTO_ALG_TYPE_MASK;
-	mask &= ~CRYPTO_ALG_TYPE_MASK;
-	type |= CRYPTO_ALG_TYPE_AHASH;
-	mask |= CRYPTO_ALG_TYPE_AHASH_MASK;
-
-	return __crypto_ahash_cast(crypto_alloc_base(alg_name, type, 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_free_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 ahash_tfm *crypto_ahash_crt(struct crypto_ahash *tfm)
-{
-	return &crypto_ahash_tfm(tfm)->crt_ahash;
-}
-
-static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
-{
-	return crypto_ahash_crt(tfm)->digestsize;
-}
-
-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 crypto_ahash_crt(tfm)->reqsize;
-}
-
-static inline int crypto_ahash_setkey(struct crypto_ahash *tfm,
-				      const u8 *key, unsigned int keylen)
-{
-	struct ahash_tfm *crt = crypto_ahash_crt(tfm);
-
-	return crt->setkey(tfm, key, keylen);
-}
-
-static inline int crypto_ahash_digest(struct ahash_request *req)
-{
-	struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
-	return crt->digest(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)
-{
-	kfree(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 complete,
-					      void *data)
-{
-	req->base.complete = complete;
-	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;
 }
  
 #endif	/* _LINUX_CRYPTO_H */
...	...	@@ -11,6 +11,7 @@
11	11	*/
12	12
13	13	#include <crypto/algapi.h>
	14	+#include <crypto/internal/hash.h>
14	15	#include <linux/err.h>
15	16	#include <linux/init.h>
16	17	#include <linux/kernel.h>
...	...	@@ -12,6 +12,7 @@
12	12	*
13	13	*/
14	14
	15	+#include <crypto/internal/hash.h>
15	16	#include <crypto/scatterwalk.h>
16	17	#include <linux/mm.h>
17	18	#include <linux/errno.h>
...	...	@@ -9,6 +9,7 @@
9	9	* any later version.
10	10	*/
11	11
	12	+#include <crypto/internal/hash.h>
12	13	#include <linux/errno.h>
13	14	#include <linux/kernel.h>
14	15	#include <linux/module.h>
...	...	@@ -15,6 +15,7 @@
15	15	*
16	16	*/
17	17
	18	+#include <crypto/hash.h>
18	19	#include <linux/err.h>
19	20	#include <linux/init.h>
20	21	#include <linux/module.h>
...	...	@@ -98,7 +98,6 @@
98	98	extern const struct crypto_type crypto_aead_type;
99	99	extern const struct crypto_type crypto_blkcipher_type;
100	100	extern const struct crypto_type crypto_hash_type;
101		-extern const struct crypto_type crypto_ahash_type;
102	101
103	102	void crypto_mod_put(struct crypto_alg *alg);
104	103
...	...	@@ -314,41 +313,6 @@
314	313	{
315	314	return (type ^ CRYPTO_ALG_ASYNC) & mask & CRYPTO_ALG_ASYNC;
316	315	}
317		-
318		-static inline void crypto_ahash_ctx(struct crypto_ahash tfm)
319		-{
320		- return crypto_tfm_ctx(&tfm->base);
321		-}
322		-
323		-static inline struct ahash_alg *crypto_ahash_alg(
324		- struct crypto_ahash *tfm)
325		-{
326		- return &crypto_ahash_tfm(tfm)->__crt_alg->cra_ahash;
327		-}
328		-
329		-static inline int ahash_enqueue_request(struct crypto_queue *queue,
330		- struct ahash_request *request)
331		-{
332		- return crypto_enqueue_request(queue, &request->base);
333		-}
334		-
335		-static inline struct ahash_request *ahash_dequeue_request(
336		- struct crypto_queue *queue)
337		-{
338		- return ahash_request_cast(crypto_dequeue_request(queue));
339		-}
340		-
341		-static inline void ahash_request_ctx(struct ahash_request req)
342		-{
343		- return req->__ctx;
344		-}
345		-
346		-static inline int ahash_tfm_in_queue(struct crypto_queue *queue,
347		- struct crypto_ahash *tfm)
348		-{
349		- return crypto_tfm_in_queue(queue, crypto_ahash_tfm(tfm));
350		-}
351		-
352	316
353	317	#endif /* _CRYPTO_ALGAPI_H */
	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	+
	18	+struct crypto_ahash {
	19	+ struct crypto_tfm base;
	20	+};
	21	+
	22	+static inline struct crypto_ahash __crypto_ahash_cast(struct crypto_tfm tfm)
	23	+{
	24	+ return (struct crypto_ahash *)tfm;
	25	+}
	26	+
	27	+static inline struct crypto_ahash crypto_alloc_ahash(const char alg_name,
	28	+ u32 type, u32 mask)
	29	+{
	30	+ type &= ~CRYPTO_ALG_TYPE_MASK;
	31	+ mask &= ~CRYPTO_ALG_TYPE_MASK;
	32	+ type \|= CRYPTO_ALG_TYPE_AHASH;
	33	+ mask \|= CRYPTO_ALG_TYPE_AHASH_MASK;
	34	+
	35	+ return __crypto_ahash_cast(crypto_alloc_base(alg_name, type, mask));
	36	+}
	37	+
	38	+static inline struct crypto_tfm crypto_ahash_tfm(struct crypto_ahash tfm)
	39	+{
	40	+ return &tfm->base;
	41	+}
	42	+
	43	+static inline void crypto_free_ahash(struct crypto_ahash *tfm)
	44	+{
	45	+ crypto_free_tfm(crypto_ahash_tfm(tfm));
	46	+}
	47	+
	48	+static inline unsigned int crypto_ahash_alignmask(
	49	+ struct crypto_ahash *tfm)
	50	+{
	51	+ return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
	52	+}
	53	+
	54	+static inline struct ahash_tfm crypto_ahash_crt(struct crypto_ahash tfm)
	55	+{
	56	+ return &crypto_ahash_tfm(tfm)->crt_ahash;
	57	+}
	58	+
	59	+static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
	60	+{
	61	+ return crypto_ahash_crt(tfm)->digestsize;
	62	+}
	63	+
	64	+static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
	65	+{
	66	+ return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
	67	+}
	68	+
	69	+static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
	70	+{
	71	+ crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
	72	+}
	73	+
	74	+static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
	75	+{
	76	+ crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
	77	+}
	78	+
	79	+static inline struct crypto_ahash *crypto_ahash_reqtfm(
	80	+ struct ahash_request *req)
	81	+{
	82	+ return __crypto_ahash_cast(req->base.tfm);
	83	+}
	84	+
	85	+static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
	86	+{
	87	+ return crypto_ahash_crt(tfm)->reqsize;
	88	+}
	89	+
	90	+static inline int crypto_ahash_setkey(struct crypto_ahash *tfm,
	91	+ const u8 *key, unsigned int keylen)
	92	+{
	93	+ struct ahash_tfm *crt = crypto_ahash_crt(tfm);
	94	+
	95	+ return crt->setkey(tfm, key, keylen);
	96	+}
	97	+
	98	+static inline int crypto_ahash_digest(struct ahash_request *req)
	99	+{
	100	+ struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
	101	+ return crt->digest(req);
	102	+}
	103	+
	104	+static inline void ahash_request_set_tfm(struct ahash_request *req,
	105	+ struct crypto_ahash *tfm)
	106	+{
	107	+ req->base.tfm = crypto_ahash_tfm(tfm);
	108	+}
	109	+
	110	+static inline struct ahash_request *ahash_request_alloc(
	111	+ struct crypto_ahash *tfm, gfp_t gfp)
	112	+{
	113	+ struct ahash_request *req;
	114	+
	115	+ req = kmalloc(sizeof(struct ahash_request) +
	116	+ crypto_ahash_reqsize(tfm), gfp);
	117	+
	118	+ if (likely(req))
	119	+ ahash_request_set_tfm(req, tfm);
	120	+
	121	+ return req;
	122	+}
	123	+
	124	+static inline void ahash_request_free(struct ahash_request *req)
	125	+{
	126	+ kfree(req);
	127	+}
	128	+
	129	+static inline struct ahash_request *ahash_request_cast(
	130	+ struct crypto_async_request *req)
	131	+{
	132	+ return container_of(req, struct ahash_request, base);
	133	+}
	134	+
	135	+static inline void ahash_request_set_callback(struct ahash_request *req,
	136	+ u32 flags,
	137	+ crypto_completion_t complete,
	138	+ void *data)
	139	+{
	140	+ req->base.complete = complete;
	141	+ req->base.data = data;
	142	+ req->base.flags = flags;
	143	+}
	144	+
	145	+static inline void ahash_request_set_crypt(struct ahash_request *req,
	146	+ struct scatterlist src, u8 result,
	147	+ unsigned int nbytes)
	148	+{
	149	+ req->src = src;
	150	+ req->nbytes = nbytes;
	151	+ req->result = result;
	152	+}
	153	+
	154	+#endif /* _CRYPTO_HASH_H */
...	...	@@ -14,6 +14,7 @@
14	14	#define _CRYPTO_INTERNAL_HASH_H
15	15
16	16	#include <crypto/algapi.h>
	17	+#include <crypto/hash.h>
17	18
18	19	struct ahash_request;
19	20	struct scatterlist;
20	21
...	...	@@ -33,9 +34,45 @@
33	34	unsigned int flags;
34	35	};
35	36
	37	+extern const struct crypto_type crypto_ahash_type;
	38	+
36	39	int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err);
37	40	int crypto_hash_walk_first(struct ahash_request *req,
38	41	struct crypto_hash_walk *walk);
	42	+
	43	+static inline void crypto_ahash_ctx(struct crypto_ahash tfm)
	44	+{
	45	+ return crypto_tfm_ctx(&tfm->base);
	46	+}
	47	+
	48	+static inline struct ahash_alg *crypto_ahash_alg(
	49	+ struct crypto_ahash *tfm)
	50	+{
	51	+ return &crypto_ahash_tfm(tfm)->__crt_alg->cra_ahash;
	52	+}
	53	+
	54	+static inline int ahash_enqueue_request(struct crypto_queue *queue,
	55	+ struct ahash_request *request)
	56	+{
	57	+ return crypto_enqueue_request(queue, &request->base);
	58	+}
	59	+
	60	+static inline struct ahash_request *ahash_dequeue_request(
	61	+ struct crypto_queue *queue)
	62	+{
	63	+ return ahash_request_cast(crypto_dequeue_request(queue));
	64	+}
	65	+
	66	+static inline void ahash_request_ctx(struct ahash_request req)
	67	+{
	68	+ return req->__ctx;
	69	+}
	70	+
	71	+static inline int ahash_tfm_in_queue(struct crypto_queue *queue,
	72	+ struct crypto_ahash *tfm)
	73	+{
	74	+ return crypto_tfm_in_queue(queue, crypto_ahash_tfm(tfm));
	75	+}
39	76
40	77	#endif /* _CRYPTO_INTERNAL_HASH_H */
...	...	@@ -481,10 +481,6 @@
481	481	struct crypto_tfm base;
482	482	};
483	483
484		-struct crypto_ahash {
485		- struct crypto_tfm base;
486		-};
487		-
488	484	enum {
489	485	CRYPTOA_UNSPEC,
490	486	CRYPTOA_ALG,
...	...	@@ -1306,138 +1302,6 @@
1306	1302	{
1307	1303	return crypto_comp_crt(tfm)->cot_decompress(crypto_comp_tfm(tfm),
1308	1304	src, slen, dst, dlen);
1309		-}
1310		-
1311		-static inline struct crypto_ahash __crypto_ahash_cast(struct crypto_tfm tfm)
1312		-{
1313		- return (struct crypto_ahash *)tfm;
1314		-}
1315		-
1316		-static inline struct crypto_ahash crypto_alloc_ahash(const char alg_name,
1317		- u32 type, u32 mask)
1318		-{
1319		- type &= ~CRYPTO_ALG_TYPE_MASK;
1320		- mask &= ~CRYPTO_ALG_TYPE_MASK;
1321		- type \|= CRYPTO_ALG_TYPE_AHASH;
1322		- mask \|= CRYPTO_ALG_TYPE_AHASH_MASK;
1323		-
1324		- return __crypto_ahash_cast(crypto_alloc_base(alg_name, type, mask));
1325		-}
1326		-
1327		-static inline struct crypto_tfm crypto_ahash_tfm(struct crypto_ahash tfm)
1328		-{
1329		- return &tfm->base;
1330		-}
1331		-
1332		-static inline void crypto_free_ahash(struct crypto_ahash *tfm)
1333		-{
1334		- crypto_free_tfm(crypto_ahash_tfm(tfm));
1335		-}
1336		-
1337		-static inline unsigned int crypto_ahash_alignmask(
1338		- struct crypto_ahash *tfm)
1339		-{
1340		- return crypto_tfm_alg_alignmask(crypto_ahash_tfm(tfm));
1341		-}
1342		-
1343		-static inline struct ahash_tfm crypto_ahash_crt(struct crypto_ahash tfm)
1344		-{
1345		- return &crypto_ahash_tfm(tfm)->crt_ahash;
1346		-}
1347		-
1348		-static inline unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm)
1349		-{
1350		- return crypto_ahash_crt(tfm)->digestsize;
1351		-}
1352		-
1353		-static inline u32 crypto_ahash_get_flags(struct crypto_ahash *tfm)
1354		-{
1355		- return crypto_tfm_get_flags(crypto_ahash_tfm(tfm));
1356		-}
1357		-
1358		-static inline void crypto_ahash_set_flags(struct crypto_ahash *tfm, u32 flags)
1359		-{
1360		- crypto_tfm_set_flags(crypto_ahash_tfm(tfm), flags);
1361		-}
1362		-
1363		-static inline void crypto_ahash_clear_flags(struct crypto_ahash *tfm, u32 flags)
1364		-{
1365		- crypto_tfm_clear_flags(crypto_ahash_tfm(tfm), flags);
1366		-}
1367		-
1368		-static inline struct crypto_ahash *crypto_ahash_reqtfm(
1369		- struct ahash_request *req)
1370		-{
1371		- return __crypto_ahash_cast(req->base.tfm);
1372		-}
1373		-
1374		-static inline unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm)
1375		-{
1376		- return crypto_ahash_crt(tfm)->reqsize;
1377		-}
1378		-
1379		-static inline int crypto_ahash_setkey(struct crypto_ahash *tfm,
1380		- const u8 *key, unsigned int keylen)
1381		-{
1382		- struct ahash_tfm *crt = crypto_ahash_crt(tfm);
1383		-
1384		- return crt->setkey(tfm, key, keylen);
1385		-}
1386		-
1387		-static inline int crypto_ahash_digest(struct ahash_request *req)
1388		-{
1389		- struct ahash_tfm *crt = crypto_ahash_crt(crypto_ahash_reqtfm(req));
1390		- return crt->digest(req);
1391		-}
1392		-
1393		-static inline void ahash_request_set_tfm(struct ahash_request *req,
1394		- struct crypto_ahash *tfm)
1395		-{
1396		- req->base.tfm = crypto_ahash_tfm(tfm);
1397		-}
1398		-
1399		-static inline struct ahash_request *ahash_request_alloc(
1400		- struct crypto_ahash *tfm, gfp_t gfp)
1401		-{
1402		- struct ahash_request *req;
1403		-
1404		- req = kmalloc(sizeof(struct ahash_request) +
1405		- crypto_ahash_reqsize(tfm), gfp);
1406		-
1407		- if (likely(req))
1408		- ahash_request_set_tfm(req, tfm);
1409		-
1410		- return req;
1411		-}
1412		-
1413		-static inline void ahash_request_free(struct ahash_request *req)
1414		-{
1415		- kfree(req);
1416		-}
1417		-
1418		-static inline struct ahash_request *ahash_request_cast(
1419		- struct crypto_async_request *req)
1420		-{
1421		- return container_of(req, struct ahash_request, base);
1422		-}
1423		-
1424		-static inline void ahash_request_set_callback(struct ahash_request *req,
1425		- u32 flags,
1426		- crypto_completion_t complete,
1427		- void *data)
1428		-{
1429		- req->base.complete = complete;
1430		- req->base.data = data;
1431		- req->base.flags = flags;
1432		-}
1433		-
1434		-static inline void ahash_request_set_crypt(struct ahash_request *req,
1435		- struct scatterlist src, u8 result,
1436		- unsigned int nbytes)
1437		-{
1438		- req->src = src;
1439		- req->nbytes = nbytes;
1440		- req->result = result;
1441	1305	}
1442	1306
1443	1307	#endif /* _LINUX_CRYPTO_H */