Eric Lee / smarc-fsl-linux-kernel

Commit 6bfd48096ff8ecabf955958b51ddfa7988eb0a14

Authored by Herbert Xu 19 years ago

Exists in master and in 39 other branches

[CRYPTO] api: Added spawns

Spawns lock a specific crypto algorithm in place.  They can then be used
with crypto_spawn_tfm to allocate a tfm for that algorithm.  When the base
algorithm of a spawn is deregistered, all its spawns will be automatically
removed.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 6 changed files with 280 additions and 53 deletions Inline Diff

crypto/algapi.c
crypto/api.c
crypto/cryptomgr.c
crypto/internal.h
include/crypto/algapi.h
include/linux/crypto.h

crypto/algapi.c

Diff comments View file @ 6bfd480

1	/*	1	/*
2	* Cryptographic API for algorithms (i.e., low-level API).	2	* Cryptographic API for algorithms (i.e., low-level API).
3	*	3	*
4	* Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>	4	* Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
5	*	5	*
6	* This program is free software; you can redistribute it and/or modify it	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	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)	8	* Software Foundation; either version 2 of the License, or (at your option)
9	* any later version.	9	* any later version.
10	*	10	*
11	*/	11	*/
12		12
		13	#include <linux/err.h>
13	#include <linux/errno.h>	14	#include <linux/errno.h>
14	#include <linux/init.h>	15	#include <linux/init.h>
15	#include <linux/kernel.h>	16	#include <linux/kernel.h>
16	#include <linux/list.h>	17	#include <linux/list.h>
17	#include <linux/module.h>	18	#include <linux/module.h>
18	#include <linux/string.h>	19	#include <linux/string.h>
19		20
20	#include "internal.h"	21	#include "internal.h"
21		22
22	static LIST_HEAD(crypto_template_list);	23	static LIST_HEAD(crypto_template_list);
23		24
24	void crypto_larval_error(const char *name, u32 type, u32 mask)	25	void crypto_larval_error(const char *name, u32 type, u32 mask)
25	{	26	{
26	struct crypto_alg *alg;	27	struct crypto_alg *alg;
27		28
28	down_read(&crypto_alg_sem);	29	down_read(&crypto_alg_sem);
29	alg = __crypto_alg_lookup(name, type, mask);	30	alg = __crypto_alg_lookup(name, type, mask);
30	up_read(&crypto_alg_sem);	31	up_read(&crypto_alg_sem);
31		32
32	if (alg) {	33	if (alg) {
33	if (crypto_is_larval(alg)) {	34	if (crypto_is_larval(alg)) {
34	struct crypto_larval larval = (void )alg;	35	struct crypto_larval larval = (void )alg;
35	complete(&larval->completion);	36	complete(&larval->completion);
36	}	37	}
37	crypto_mod_put(alg);	38	crypto_mod_put(alg);
38	}	39	}
39	}	40	}
40	EXPORT_SYMBOL_GPL(crypto_larval_error);	41	EXPORT_SYMBOL_GPL(crypto_larval_error);
41		42
42	static inline int crypto_set_driver_name(struct crypto_alg *alg)	43	static inline int crypto_set_driver_name(struct crypto_alg *alg)
43	{	44	{
44	static const char suffix[] = "-generic";	45	static const char suffix[] = "-generic";
45	char *driver_name = alg->cra_driver_name;	46	char *driver_name = alg->cra_driver_name;
46	int len;	47	int len;
47		48
48	if (*driver_name)	49	if (*driver_name)
49	return 0;	50	return 0;
50		51
51	len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);	52	len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
52	if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)	53	if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)
53	return -ENAMETOOLONG;	54	return -ENAMETOOLONG;
54		55
55	memcpy(driver_name + len, suffix, sizeof(suffix));	56	memcpy(driver_name + len, suffix, sizeof(suffix));
56	return 0;	57	return 0;
57	}	58	}
58		59
59	static int crypto_check_alg(struct crypto_alg *alg)	60	static int crypto_check_alg(struct crypto_alg *alg)
60	{	61	{
61	if (alg->cra_alignmask & (alg->cra_alignmask + 1))	62	if (alg->cra_alignmask & (alg->cra_alignmask + 1))
62	return -EINVAL;	63	return -EINVAL;
63		64
64	if (alg->cra_alignmask & alg->cra_blocksize)	65	if (alg->cra_alignmask & alg->cra_blocksize)
65	return -EINVAL;	66	return -EINVAL;
66		67
67	if (alg->cra_blocksize > PAGE_SIZE / 8)	68	if (alg->cra_blocksize > PAGE_SIZE / 8)
68	return -EINVAL;	69	return -EINVAL;
69		70
70	if (alg->cra_priority < 0)	71	if (alg->cra_priority < 0)
71	return -EINVAL;	72	return -EINVAL;
72		73
73	return crypto_set_driver_name(alg);	74	return crypto_set_driver_name(alg);
74	}	75	}
75		76
76	static int __crypto_register_alg(struct crypto_alg *alg)	77	static void crypto_destroy_instance(struct crypto_alg *alg)
77	{	78	{
		79	struct crypto_instance inst = (void )alg;
		80	struct crypto_template *tmpl = inst->tmpl;
		81
		82	tmpl->free(inst);
		83	crypto_tmpl_put(tmpl);
		84	}
		85
		86	static void crypto_remove_spawns(struct list_head *spawns,
		87	struct list_head *list)
		88	{
		89	struct crypto_spawn spawn, n;
		90
		91	list_for_each_entry_safe(spawn, n, spawns, list) {
		92	struct crypto_instance *inst = spawn->inst;
		93	struct crypto_template *tmpl = inst->tmpl;
		94
		95	list_del_init(&spawn->list);
		96	spawn->alg = NULL;
		97
		98	if (crypto_is_dead(&inst->alg))
		99	continue;
		100
		101	inst->alg.cra_flags \|= CRYPTO_ALG_DEAD;
		102	if (!tmpl \|\| !crypto_tmpl_get(tmpl))
		103	continue;
		104
		105	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg);
		106	list_move(&inst->alg.cra_list, list);
		107	hlist_del(&inst->list);
		108	inst->alg.cra_destroy = crypto_destroy_instance;
		109
		110	if (!list_empty(&inst->alg.cra_users)) {
		111	if (&n->list == spawns)
		112	n = list_entry(inst->alg.cra_users.next,
		113	typeof(*n), list);
		114	__list_splice(&inst->alg.cra_users, spawns->prev);
		115	}
		116	}
		117	}
		118
		119	static int __crypto_register_alg(struct crypto_alg *alg,
		120	struct list_head *list)
		121	{
78	struct crypto_alg *q;	122	struct crypto_alg *q;
79	int ret = -EEXIST;	123	int ret = -EAGAIN;
80		124
		125	if (crypto_is_dead(alg))
		126	goto out;
		127
		128	INIT_LIST_HEAD(&alg->cra_users);
		129
		130	ret = -EEXIST;
		131
81	atomic_set(&alg->cra_refcnt, 1);	132	atomic_set(&alg->cra_refcnt, 1);
82	list_for_each_entry(q, &crypto_alg_list, cra_list) {	133	list_for_each_entry(q, &crypto_alg_list, cra_list) {
83	if (q == alg)	134	if (q == alg)
84	goto out;	135	goto out;
85	if (crypto_is_larval(q) &&	136
86	(!strcmp(alg->cra_name, q->cra_name) \|\|	137	if (crypto_is_moribund(q))
87	!strcmp(alg->cra_driver_name, q->cra_name))) {	138	continue;
		139
		140	if (crypto_is_larval(q)) {
88	struct crypto_larval larval = (void )q;	141	struct crypto_larval larval = (void )q;
89		142
		143	if (strcmp(alg->cra_name, q->cra_name) &&
		144	strcmp(alg->cra_driver_name, q->cra_name))
		145	continue;
		146
		147	if (larval->adult)
		148	continue;
90	if ((q->cra_flags ^ alg->cra_flags) & larval->mask)	149	if ((q->cra_flags ^ alg->cra_flags) & larval->mask)
91	continue;	150	continue;
92	if (!crypto_mod_get(alg))	151	if (!crypto_mod_get(alg))
93	continue;	152	continue;
		153
94	larval->adult = alg;	154	larval->adult = alg;
95	complete(&larval->completion);	155	complete(&larval->completion);
		156	continue;
96	}	157	}
		158
		159	if (strcmp(alg->cra_name, q->cra_name))
		160	continue;
		161
		162	if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&
		163	q->cra_priority > alg->cra_priority)
		164	continue;
		165
		166	crypto_remove_spawns(&q->cra_users, list);
97	}	167	}
98		168
99	list_add(&alg->cra_list, &crypto_alg_list);	169	list_add(&alg->cra_list, &crypto_alg_list);
100		170
101	crypto_notify(CRYPTO_MSG_ALG_REGISTER, alg);	171	crypto_notify(CRYPTO_MSG_ALG_REGISTER, alg);
102	ret = 0;	172	ret = 0;
103		173
104	out:	174	out:
105	return ret;	175	return ret;
106	}	176	}
107		177
		178	static void crypto_remove_final(struct list_head *list)
		179	{
		180	struct crypto_alg *alg;
		181	struct crypto_alg *n;
		182
		183	list_for_each_entry_safe(alg, n, list, cra_list) {
		184	list_del_init(&alg->cra_list);
		185	crypto_alg_put(alg);
		186	}
		187	}
		188
108	int crypto_register_alg(struct crypto_alg *alg)	189	int crypto_register_alg(struct crypto_alg *alg)
109	{	190	{
		191	LIST_HEAD(list);
110	int err;	192	int err;
111		193
112	err = crypto_check_alg(alg);	194	err = crypto_check_alg(alg);
113	if (err)	195	if (err)
114	return err;	196	return err;
115		197
116	down_write(&crypto_alg_sem);	198	down_write(&crypto_alg_sem);
117	err = __crypto_register_alg(alg);	199	err = __crypto_register_alg(alg, &list);
118	up_write(&crypto_alg_sem);	200	up_write(&crypto_alg_sem);
119		201
		202	crypto_remove_final(&list);
120	return err;	203	return err;
121	}	204	}
122	EXPORT_SYMBOL_GPL(crypto_register_alg);	205	EXPORT_SYMBOL_GPL(crypto_register_alg);
123		206
		207	static int crypto_remove_alg(struct crypto_alg alg, struct list_head list)
		208	{
		209	if (unlikely(list_empty(&alg->cra_list)))
		210	return -ENOENT;
		211
		212	alg->cra_flags \|= CRYPTO_ALG_DEAD;
		213
		214	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg);
		215	list_del_init(&alg->cra_list);
		216	crypto_remove_spawns(&alg->cra_users, list);
		217
		218	return 0;
		219	}
		220
124	int crypto_unregister_alg(struct crypto_alg *alg)	221	int crypto_unregister_alg(struct crypto_alg *alg)
125	{	222	{
126	int ret = -ENOENT;	223	int ret;
		224	LIST_HEAD(list);
127		225
128	down_write(&crypto_alg_sem);	226	down_write(&crypto_alg_sem);
129	if (likely(!list_empty(&alg->cra_list))) {	227	ret = crypto_remove_alg(alg, &list);
130	list_del_init(&alg->cra_list);
131	ret = 0;
132	}
133	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg);
134	up_write(&crypto_alg_sem);	228	up_write(&crypto_alg_sem);
135		229
136	if (ret)	230	if (ret)
137	return ret;	231	return ret;
138		232
139	BUG_ON(atomic_read(&alg->cra_refcnt) != 1);	233	BUG_ON(atomic_read(&alg->cra_refcnt) != 1);
140	if (alg->cra_destroy)	234	if (alg->cra_destroy)
141	alg->cra_destroy(alg);	235	alg->cra_destroy(alg);
142		236
		237	crypto_remove_final(&list);
143	return 0;	238	return 0;
144	}	239	}
145	EXPORT_SYMBOL_GPL(crypto_unregister_alg);	240	EXPORT_SYMBOL_GPL(crypto_unregister_alg);
146		241
147	int crypto_register_template(struct crypto_template *tmpl)	242	int crypto_register_template(struct crypto_template *tmpl)
148	{	243	{
149	struct crypto_template *q;	244	struct crypto_template *q;
150	int err = -EEXIST;	245	int err = -EEXIST;
151		246
152	down_write(&crypto_alg_sem);	247	down_write(&crypto_alg_sem);
153		248
154	list_for_each_entry(q, &crypto_template_list, list) {	249	list_for_each_entry(q, &crypto_template_list, list) {
155	if (q == tmpl)	250	if (q == tmpl)
156	goto out;	251	goto out;
157	}	252	}
158		253
159	list_add(&tmpl->list, &crypto_template_list);	254	list_add(&tmpl->list, &crypto_template_list);
160	crypto_notify(CRYPTO_MSG_TMPL_REGISTER, tmpl);	255	crypto_notify(CRYPTO_MSG_TMPL_REGISTER, tmpl);
161	err = 0;	256	err = 0;
162	out:	257	out:
163	up_write(&crypto_alg_sem);	258	up_write(&crypto_alg_sem);
164	return err;	259	return err;
165	}	260	}
166	EXPORT_SYMBOL_GPL(crypto_register_template);	261	EXPORT_SYMBOL_GPL(crypto_register_template);
167		262
168	void crypto_unregister_template(struct crypto_template *tmpl)	263	void crypto_unregister_template(struct crypto_template *tmpl)
169	{	264	{
170	struct crypto_instance *inst;	265	struct crypto_instance *inst;
171	struct hlist_node p, n;	266	struct hlist_node p, n;
172	struct hlist_head *list;	267	struct hlist_head *list;
		268	LIST_HEAD(users);
173		269
174	down_write(&crypto_alg_sem);	270	down_write(&crypto_alg_sem);
175		271
176	BUG_ON(list_empty(&tmpl->list));	272	BUG_ON(list_empty(&tmpl->list));
177	list_del_init(&tmpl->list);	273	list_del_init(&tmpl->list);
178		274
179	list = &tmpl->instances;	275	list = &tmpl->instances;
180	hlist_for_each_entry(inst, p, list, list) {	276	hlist_for_each_entry(inst, p, list, list) {
181	BUG_ON(list_empty(&inst->alg.cra_list));	277	int err = crypto_remove_alg(&inst->alg, &users);
182	list_del_init(&inst->alg.cra_list);	278	BUG_ON(err);
183	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg);
184	}	279	}
185		280
186	crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER, tmpl);	281	crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER, tmpl);
187		282
188	up_write(&crypto_alg_sem);	283	up_write(&crypto_alg_sem);
189		284
190	hlist_for_each_entry_safe(inst, p, n, list, list) {	285	hlist_for_each_entry_safe(inst, p, n, list, list) {
191	BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1);	286	BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1);
192	tmpl->free(inst);	287	tmpl->free(inst);
193	}	288	}
		289	crypto_remove_final(&users);
194	}	290	}
195	EXPORT_SYMBOL_GPL(crypto_unregister_template);	291	EXPORT_SYMBOL_GPL(crypto_unregister_template);
196		292
197	static struct crypto_template __crypto_lookup_template(const char name)	293	static struct crypto_template __crypto_lookup_template(const char name)
198	{	294	{
199	struct crypto_template q, tmpl = NULL;	295	struct crypto_template q, tmpl = NULL;
200		296
201	down_read(&crypto_alg_sem);	297	down_read(&crypto_alg_sem);
202	list_for_each_entry(q, &crypto_template_list, list) {	298	list_for_each_entry(q, &crypto_template_list, list) {
203	if (strcmp(q->name, name))	299	if (strcmp(q->name, name))
204	continue;	300	continue;
205	if (unlikely(!crypto_tmpl_get(q)))	301	if (unlikely(!crypto_tmpl_get(q)))
206	continue;	302	continue;
207		303
208	tmpl = q;	304	tmpl = q;
209	break;	305	break;
210	}	306	}
211	up_read(&crypto_alg_sem);	307	up_read(&crypto_alg_sem);
212		308
213	return tmpl;	309	return tmpl;
214	}	310	}
215		311
216	struct crypto_template crypto_lookup_template(const char name)	312	struct crypto_template crypto_lookup_template(const char name)
217	{	313	{
218	return try_then_request_module(__crypto_lookup_template(name), name);	314	return try_then_request_module(__crypto_lookup_template(name), name);
219	}	315	}
220	EXPORT_SYMBOL_GPL(crypto_lookup_template);	316	EXPORT_SYMBOL_GPL(crypto_lookup_template);
221		317
222	int crypto_register_instance(struct crypto_template *tmpl,	318	int crypto_register_instance(struct crypto_template *tmpl,
223	struct crypto_instance *inst)	319	struct crypto_instance *inst)
224	{	320	{
		321	LIST_HEAD(list);
225	int err = -EINVAL;	322	int err = -EINVAL;
226		323
227	if (inst->alg.cra_destroy)	324	if (inst->alg.cra_destroy)
228	goto err;	325	goto err;
229		326
230	err = crypto_check_alg(&inst->alg);	327	err = crypto_check_alg(&inst->alg);
231	if (err)	328	if (err)
232	goto err;	329	goto err;
233		330
234	inst->alg.cra_module = tmpl->module;	331	inst->alg.cra_module = tmpl->module;
235		332
236	down_write(&crypto_alg_sem);	333	down_write(&crypto_alg_sem);
237		334
238	err = __crypto_register_alg(&inst->alg);	335	err = __crypto_register_alg(&inst->alg, &list);
239	if (err)	336	if (err)
240	goto unlock;	337	goto unlock;
241		338
242	hlist_add_head(&inst->list, &tmpl->instances);	339	hlist_add_head(&inst->list, &tmpl->instances);
243	inst->tmpl = tmpl;	340	inst->tmpl = tmpl;
244		341
245	unlock:	342	unlock:
246	up_write(&crypto_alg_sem);	343	up_write(&crypto_alg_sem);
247		344
		345	crypto_remove_final(&list);
		346
248	err:	347	err:
249	return err;	348	return err;
250	}	349	}
251	EXPORT_SYMBOL_GPL(crypto_register_instance);	350	EXPORT_SYMBOL_GPL(crypto_register_instance);
		351
		352	int crypto_init_spawn(struct crypto_spawn spawn, struct crypto_alg alg,
		353	struct crypto_instance *inst)
		354	{
		355	int err = -EAGAIN;
		356
		357	spawn->inst = inst;
		358
		359	down_write(&crypto_alg_sem);
		360	if (!crypto_is_moribund(alg)) {
		361	list_add(&spawn->list, &alg->cra_users);
		362	spawn->alg = alg;
		363	err = 0;
		364	}
		365	up_write(&crypto_alg_sem);
		366
		367	return err;
		368	}
		369	EXPORT_SYMBOL_GPL(crypto_init_spawn);
		370
		371	void crypto_drop_spawn(struct crypto_spawn *spawn)
		372	{
		373	down_write(&crypto_alg_sem);
		374	list_del(&spawn->list);
		375	up_write(&crypto_alg_sem);
		376	}
		377	EXPORT_SYMBOL_GPL(crypto_drop_spawn);
		378
		379	struct crypto_tfm crypto_spawn_tfm(struct crypto_spawn spawn)
		380	{
		381	struct crypto_alg *alg;
		382	struct crypto_alg *alg2;
		383	struct crypto_tfm *tfm;
		384
		385	down_read(&crypto_alg_sem);
		386	alg = spawn->alg;
		387	alg2 = alg;
		388	if (alg2)
		389	alg2 = crypto_mod_get(alg2);
		390	up_read(&crypto_alg_sem);
		391
		392	if (!alg2) {
		393	if (alg)
		394	crypto_shoot_alg(alg);
		395	return ERR_PTR(-EAGAIN);
		396	}
		397
		398	tfm = __crypto_alloc_tfm(alg, 0);
		399	if (IS_ERR(tfm))
		400	crypto_mod_put(alg);
		401
		402	return tfm;
		403	}
		404	EXPORT_SYMBOL_GPL(crypto_spawn_tfm);
252		405
253	int crypto_register_notifier(struct notifier_block *nb)	406	int crypto_register_notifier(struct notifier_block *nb)
254	{	407	{
255	return blocking_notifier_chain_register(&crypto_chain, nb);	408	return blocking_notifier_chain_register(&crypto_chain, nb);
256	}	409	}
257	EXPORT_SYMBOL_GPL(crypto_register_notifier);	410	EXPORT_SYMBOL_GPL(crypto_register_notifier);
258		411
259	int crypto_unregister_notifier(struct notifier_block *nb)	412	int crypto_unregister_notifier(struct notifier_block *nb)
260	{	413	{
261	return blocking_notifier_chain_unregister(&crypto_chain, nb);	414	return blocking_notifier_chain_unregister(&crypto_chain, nb);
262	}	415	}
263	EXPORT_SYMBOL_GPL(crypto_unregister_notifier);	416	EXPORT_SYMBOL_GPL(crypto_unregister_notifier);
264		417
265	static int __init crypto_algapi_init(void)	418	static int __init crypto_algapi_init(void)
266	{	419	{
267	crypto_init_proc();	420	crypto_init_proc();
268	return 0;	421	return 0;
269	}	422	}
270		423
271	static void __exit crypto_algapi_exit(void)	424	static void __exit crypto_algapi_exit(void)
272	{	425	{
273	crypto_exit_proc();	426	crypto_exit_proc();
274	}	427	}
275		428
276	module_init(crypto_algapi_init);	429	module_init(crypto_algapi_init);

crypto/api.c

Diff comments View file @ 6bfd480

 /*
  * Scatterlist Cryptographic API.
  *
  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
  * Copyright (c) 2002 David S. Miller (davem@redhat.com)
  * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
  *
  * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
  * and Nettle, by Niels Möller.
  *
  * 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.
  *
  */
+#include <linux/err.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/kmod.h>
 #include <linux/module.h>
 #include <linux/param.h>
+#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 #include "internal.h"
 LIST_HEAD(crypto_alg_list);
 EXPORT_SYMBOL_GPL(crypto_alg_list);
 DECLARE_RWSEM(crypto_alg_sem);
 EXPORT_SYMBOL_GPL(crypto_alg_sem);
 BLOCKING_NOTIFIER_HEAD(crypto_chain);
 EXPORT_SYMBOL_GPL(crypto_chain);
 static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg)
 {
 	atomic_inc(&alg->cra_refcnt);
 	return alg;
 }
-static inline void crypto_alg_put(struct crypto_alg *alg)
-{
-	if (atomic_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy)
-		alg->cra_destroy(alg);
-}
 struct crypto_alg *crypto_mod_get(struct crypto_alg *alg)
 {
 	return try_module_get(alg->cra_module) ? crypto_alg_get(alg) : NULL;
 }
 EXPORT_SYMBOL_GPL(crypto_mod_get);
 void crypto_mod_put(struct crypto_alg *alg)
 {
 	crypto_alg_put(alg);
 	module_put(alg->cra_module);
 }
 EXPORT_SYMBOL_GPL(crypto_mod_put);
 struct crypto_alg *__crypto_alg_lookup(const char *name, u32 type, u32 mask)
 {
 	struct crypto_alg *q, *alg = NULL;
 	int best = -2;
 	list_for_each_entry(q, &crypto_alg_list, cra_list) {
 		int exact, fuzzy;
+		if (crypto_is_moribund(q))
+			continue;
 		if ((q->cra_flags ^ type) & mask)
 			continue;
 		if (crypto_is_larval(q) &&
 		    ((struct crypto_larval *)q)->mask != mask)
 			continue;
 		exact = !strcmp(q->cra_driver_name, name);
 		fuzzy = !strcmp(q->cra_name, name);
 		if (!exact && !(fuzzy && q->cra_priority > best))
 			continue;
 		if (unlikely(!crypto_mod_get(q)))
 			continue;
 		best = q->cra_priority;
 		if (alg)
 			crypto_mod_put(alg);
 		alg = q;
 		if (exact)
 			break;
 	}
 	return alg;
 }
 EXPORT_SYMBOL_GPL(__crypto_alg_lookup);
 static void crypto_larval_destroy(struct crypto_alg *alg)
 {
 	struct crypto_larval *larval = (void *)alg;
 	BUG_ON(!crypto_is_larval(alg));
 	if (larval->adult)
 		crypto_mod_put(larval->adult);
 	kfree(larval);
 }
 static struct crypto_alg *crypto_larval_alloc(const char *name, u32 type,
 					      u32 mask)
 {
 	struct crypto_alg *alg;
 	struct crypto_larval *larval;
 	larval = kzalloc(sizeof(*larval), GFP_KERNEL);
 	if (!larval)
-		return NULL;
+		return ERR_PTR(-ENOMEM);
 	larval->mask = mask;
 	larval->alg.cra_flags = CRYPTO_ALG_LARVAL | type;
 	larval->alg.cra_priority = -1;
 	larval->alg.cra_destroy = crypto_larval_destroy;
 	atomic_set(&larval->alg.cra_refcnt, 2);
 	strlcpy(larval->alg.cra_name, name, CRYPTO_MAX_ALG_NAME);
 	init_completion(&larval->completion);
 	down_write(&crypto_alg_sem);
 	alg = __crypto_alg_lookup(name, type, mask);
 	if (!alg) {
 		alg = &larval->alg;
 		list_add(&alg->cra_list, &crypto_alg_list);
 	}
 	up_write(&crypto_alg_sem);
 	if (alg != &larval->alg)
 		kfree(larval);
 	return alg;
 }
 static void crypto_larval_kill(struct crypto_alg *alg)
 {
 	struct crypto_larval *larval = (void *)alg;
 	down_write(&crypto_alg_sem);
 	list_del(&alg->cra_list);
 	up_write(&crypto_alg_sem);
 	complete(&larval->completion);
 	crypto_alg_put(alg);
 }
 static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)
 {
 	struct crypto_larval *larval = (void *)alg;
 	wait_for_completion_interruptible_timeout(&larval->completion, 60 * HZ);
 	alg = larval->adult;
-	if (alg && !crypto_mod_get(alg))
+	if (alg) {
-		alg = NULL;
+		if (!crypto_mod_get(alg))
+			alg = ERR_PTR(-EAGAIN);
+	} else
+		alg = ERR_PTR(-ENOENT);
 	crypto_mod_put(&larval->alg);
 	return alg;
 }
 static struct crypto_alg *crypto_alg_lookup(const char *name, u32 type,
 					    u32 mask)
 {
 	struct crypto_alg *alg;
-	if (!name)
-		return NULL;
 	down_read(&crypto_alg_sem);
 	alg = __crypto_alg_lookup(name, type, mask);
 	up_read(&crypto_alg_sem);
 	return alg;
 }
 struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask)
 {
 	struct crypto_alg *alg;
 	struct crypto_alg *larval;
 	int ok;
-	mask &= ~CRYPTO_ALG_LARVAL;
+	if (!name)
+		return ERR_PTR(-ENOENT);
+	mask &= ~(CRYPTO_ALG_LARVAL | CRYPTO_ALG_DEAD);
 	type &= mask;
 	alg = try_then_request_module(crypto_alg_lookup(name, type, mask),
 				      name);
 	if (alg)
 		return crypto_is_larval(alg) ? crypto_larval_wait(alg) : alg;
 	larval = crypto_larval_alloc(name, type, mask);
-	if (!larval || !crypto_is_larval(larval))
+	if (IS_ERR(larval) || !crypto_is_larval(larval))
 		return larval;
 	ok = crypto_notify(CRYPTO_MSG_ALG_REQUEST, larval);
 	if (ok == NOTIFY_DONE) {
 		request_module("cryptomgr");
 		ok = crypto_notify(CRYPTO_MSG_ALG_REQUEST, larval);
 	}
 	if (ok == NOTIFY_STOP)
 		alg = crypto_larval_wait(larval);
 	else {
 		crypto_mod_put(larval);
-		alg = NULL;
+		alg = ERR_PTR(-ENOENT);
 	}
 	crypto_larval_kill(larval);
 	return alg;
 }
 EXPORT_SYMBOL_GPL(crypto_alg_mod_lookup);
 static int crypto_init_flags(struct crypto_tfm *tfm, u32 flags)
 {
 	tfm->crt_flags = flags & CRYPTO_TFM_REQ_MASK;
 	flags &= ~CRYPTO_TFM_REQ_MASK;
 	switch (crypto_tfm_alg_type(tfm)) {
 	case CRYPTO_ALG_TYPE_CIPHER:
 		return crypto_init_cipher_flags(tfm, flags);
 	case CRYPTO_ALG_TYPE_DIGEST:
 		return crypto_init_digest_flags(tfm, flags);
 	case CRYPTO_ALG_TYPE_COMPRESS:
 		return crypto_init_compress_flags(tfm, flags);
 	default:
 		break;
 	}
 	BUG();
 	return -EINVAL;
 }
 static int crypto_init_ops(struct crypto_tfm *tfm)
 {
 	switch (crypto_tfm_alg_type(tfm)) {
 	case CRYPTO_ALG_TYPE_CIPHER:
 		return crypto_init_cipher_ops(tfm);
 	case CRYPTO_ALG_TYPE_DIGEST:
 		return crypto_init_digest_ops(tfm);
 	case CRYPTO_ALG_TYPE_COMPRESS:
 		return crypto_init_compress_ops(tfm);
 	default:
 		break;
 	}
 	BUG();
 	return -EINVAL;
 }
 static void crypto_exit_ops(struct crypto_tfm *tfm)
 {
 	switch (crypto_tfm_alg_type(tfm)) {
 	case CRYPTO_ALG_TYPE_CIPHER:
 		crypto_exit_cipher_ops(tfm);
 		break;
 	case CRYPTO_ALG_TYPE_DIGEST:
 		crypto_exit_digest_ops(tfm);
 		break;
 	case CRYPTO_ALG_TYPE_COMPRESS:
 		crypto_exit_compress_ops(tfm);
 		break;
 	default:
 		BUG();
 	}
 }
 static unsigned int crypto_ctxsize(struct crypto_alg *alg, int flags)
 {
 	unsigned int len;
 	switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
 	default:
 		BUG();
 	case CRYPTO_ALG_TYPE_CIPHER:
 		len = crypto_cipher_ctxsize(alg, flags);
 		break;
 	case CRYPTO_ALG_TYPE_DIGEST:
 		len = crypto_digest_ctxsize(alg, flags);
 		break;
 	case CRYPTO_ALG_TYPE_COMPRESS:
 		len = crypto_compress_ctxsize(alg, flags);
 		break;
 	}
 	return len + (alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1));
 }
-struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
+void crypto_shoot_alg(struct crypto_alg *alg)
 {
+	down_write(&crypto_alg_sem);
+	alg->cra_flags |= CRYPTO_ALG_DYING;
+	up_write(&crypto_alg_sem);
+}
+EXPORT_SYMBOL_GPL(crypto_shoot_alg);
+struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 flags)
+{
 	struct crypto_tfm *tfm = NULL;
-	struct crypto_alg *alg;
 	unsigned int tfm_size;
+	int err = -ENOMEM;
-	alg = crypto_alg_mod_lookup(name, 0, 0);
-	if (alg == NULL)
-		goto out;
 	tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, flags);
 	tfm = kzalloc(tfm_size, GFP_KERNEL);
 	if (tfm == NULL)
-		goto out_put;
+		goto out;
 	tfm->__crt_alg = alg;
-	if (crypto_init_flags(tfm, flags))
+	err = crypto_init_flags(tfm, flags);
+	if (err)
 		goto out_free_tfm;
-	if (crypto_init_ops(tfm))
+	err = crypto_init_ops(tfm);
+	if (err)
 		goto out_free_tfm;
-	if (alg->cra_init && alg->cra_init(tfm))
+	if (alg->cra_init && (err = alg->cra_init(tfm))) {
+		if (err == -EAGAIN)
+			crypto_shoot_alg(alg);
 		goto cra_init_failed;
+	}
 	goto out;
 cra_init_failed:
 	crypto_exit_ops(tfm);
 out_free_tfm:
 	kfree(tfm);
-	tfm = NULL;
+	tfm = ERR_PTR(err);
-out_put:
-	crypto_mod_put(alg);
 out:
 	return tfm;
 }
+EXPORT_SYMBOL_GPL(__crypto_alloc_tfm);
+struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
+{
+	struct crypto_tfm *tfm = NULL;
+	int err;
+	do {
+		struct crypto_alg *alg;
+		alg = crypto_alg_mod_lookup(name, 0, 0);
+		err = PTR_ERR(alg);
+		if (IS_ERR(alg))
+			continue;
+		tfm = __crypto_alloc_tfm(alg, flags);
+		err = 0;
+		if (IS_ERR(tfm)) {
+			crypto_mod_put(alg);
+			err = PTR_ERR(tfm);
+			tfm = NULL;
+		}
+	} while (err == -EAGAIN && !signal_pending(current));
+	return tfm;
+}
 void crypto_free_tfm(struct crypto_tfm *tfm)
 {
 	struct crypto_alg *alg;
 	int size;
 	if (unlikely(!tfm))
 		return;
 	alg = tfm->__crt_alg;
 	size = sizeof(*tfm) + alg->cra_ctxsize;
 	if (alg->cra_exit)
 		alg->cra_exit(tfm);
 	crypto_exit_ops(tfm);
 	crypto_mod_put(alg);
 	memset(tfm, 0, size);
 	kfree(tfm);
 }
 int crypto_alg_available(const char *name, u32 flags)

crypto/cryptomgr.c

Diff comments View file @ 6bfd480

 /*
  * Create default crypto algorithm instances.
  *
  * Copyright (c) 2006 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.
  *
  */
 #include <linux/crypto.h>
 #include <linux/ctype.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/notifier.h>
 #include <linux/rtnetlink.h>
+#include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/workqueue.h>
 #include "internal.h"
 struct cryptomgr_param {
 	struct work_struct work;
 	struct {
 		struct rtattr attr;
 		struct crypto_attr_alg data;
 	} alg;
 	struct {
 		u32 type;
 		u32 mask;
 		char name[CRYPTO_MAX_ALG_NAME];
 	} larval;
 	char template[CRYPTO_MAX_ALG_NAME];
 };
 static void cryptomgr_probe(void *data)
 {
 	struct cryptomgr_param *param = data;
 	struct crypto_template *tmpl;
 	struct crypto_instance *inst;
+	int err;
 	tmpl = crypto_lookup_template(param->template);
 	if (!tmpl)
 		goto err;
-	inst = tmpl->alloc(&param->alg, sizeof(param->alg));
+	do {
-	if (IS_ERR(inst))
+		inst = tmpl->alloc(&param->alg, sizeof(param->alg));
-		goto err;
+		if (IS_ERR(inst))
-	else if ((err = crypto_register_instance(tmpl, inst))) {
+			err = PTR_ERR(inst);
-		tmpl->free(inst);
+		else if ((err = crypto_register_instance(tmpl, inst)))
-		goto err;
+			tmpl->free(inst);
-	}
+	} while (err == -EAGAIN && !signal_pending(current));
 	crypto_tmpl_put(tmpl);
+	if (err)
+		goto err;
 out:
 	kfree(param);
 	return;
 err:
 	crypto_larval_error(param->larval.name, param->larval.type,
 			    param->larval.mask);
 	goto out;
 }
 static int cryptomgr_schedule_probe(struct crypto_larval *larval)
 {
 	struct cryptomgr_param *param;
 	const char *name = larval->alg.cra_name;
 	const char *p;
 	unsigned int len;
 	param = kmalloc(sizeof(*param), GFP_KERNEL);
 	if (!param)
 		goto err;
 	for (p = name; isalnum(*p) || *p == '-' || *p == '_'; p++)
 		;
 	len = p - name;
 	if (!len || *p != '(')
 		goto err_free_param;
 	memcpy(param->template, name, len);
 	param->template[len] = 0;
 	name = p + 1;
 	for (p = name; isalnum(*p) || *p == '-' || *p == '_'; p++)
 		;
 	len = p - name;
 	if (!len || *p != ')' || p[1])
 		goto err_free_param;
 	param->alg.attr.rta_len = sizeof(param->alg);
 	param->alg.attr.rta_type = CRYPTOA_ALG;
 	memcpy(param->alg.data.name, name, len);
 	param->alg.data.name[len] = 0;
 	memcpy(param->larval.name, larval->alg.cra_name, CRYPTO_MAX_ALG_NAME);
 	param->larval.type = larval->alg.cra_flags;
 	param->larval.mask = larval->mask;
 	INIT_WORK(&param->work, cryptomgr_probe, param);
 	schedule_work(&param->work);
 	return NOTIFY_STOP;
 err_free_param:
 	kfree(param);
 err:
 	return NOTIFY_OK;
 }
 static int cryptomgr_notify(struct notifier_block *this, unsigned long msg,
 			    void *data)
 {
 	switch (msg) {
 	case CRYPTO_MSG_ALG_REQUEST:
 		return cryptomgr_schedule_probe(data);
 	}
 	return NOTIFY_DONE;
 }
 static struct notifier_block cryptomgr_notifier = {
 	.notifier_call = cryptomgr_notify,
 };
 static int __init cryptomgr_init(void)
 {
 	return crypto_register_notifier(&cryptomgr_notifier);
 }
 static void __exit cryptomgr_exit(void)
 {
 	int err = crypto_unregister_notifier(&cryptomgr_notifier);
 	BUG_ON(err);
 }
 module_init(cryptomgr_init);
 module_exit(cryptomgr_exit);
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Crypto Algorithm Manager");

crypto/internal.h

Diff comments View file @ 6bfd480

 /*
  * Cryptographic API.
  *
  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
  * Copyright (c) 2005 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_INTERNAL_H
 #define _CRYPTO_INTERNAL_H
 #include <crypto/algapi.h>
 #include <linux/completion.h>
 #include <linux/mm.h>
 #include <linux/highmem.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/notifier.h>
 #include <linux/rwsem.h>
 #include <linux/slab.h>
 #include <asm/kmap_types.h>
 /* Crypto notification events. */
 enum {
 	CRYPTO_MSG_ALG_REQUEST,
 	CRYPTO_MSG_ALG_REGISTER,
 	CRYPTO_MSG_ALG_UNREGISTER,
 	CRYPTO_MSG_TMPL_REGISTER,
 	CRYPTO_MSG_TMPL_UNREGISTER,
 };
 struct crypto_instance;
 struct crypto_template;
 struct crypto_larval {
 	struct crypto_alg alg;
 	struct crypto_alg *adult;
 	struct completion completion;
 	u32 mask;
 };
 extern struct list_head crypto_alg_list;
 extern struct rw_semaphore crypto_alg_sem;
 extern struct blocking_notifier_head crypto_chain;
 extern enum km_type crypto_km_types[];
 static inline enum km_type crypto_kmap_type(int out)
 {
 	return crypto_km_types[(in_softirq() ? 2 : 0) + out];
 }
 static inline void *crypto_kmap(struct page *page, int out)
 {
 	return kmap_atomic(page, crypto_kmap_type(out));
 }
 static inline void crypto_kunmap(void *vaddr, int out)
 {
 	kunmap_atomic(vaddr, crypto_kmap_type(out));
 }
 static inline void crypto_yield(struct crypto_tfm *tfm)
 {
 	if (tfm->crt_flags & CRYPTO_TFM_REQ_MAY_SLEEP)
 		cond_resched();
 }
 #ifdef CONFIG_CRYPTO_HMAC
 int crypto_alloc_hmac_block(struct crypto_tfm *tfm);
 void crypto_free_hmac_block(struct crypto_tfm *tfm);
 #else
 static inline int crypto_alloc_hmac_block(struct crypto_tfm *tfm)
 {
 	return 0;
 }
 static inline void crypto_free_hmac_block(struct crypto_tfm *tfm)
 { }
 #endif
 #ifdef CONFIG_PROC_FS
 void __init crypto_init_proc(void);
 void __exit crypto_exit_proc(void);
 #else
 static inline void crypto_init_proc(void)
 { }
 static inline void crypto_exit_proc(void)
 { }
 #endif
 static inline unsigned int crypto_digest_ctxsize(struct crypto_alg *alg,
 						 int flags)
 {
 	return alg->cra_ctxsize;
 }
 static inline unsigned int crypto_cipher_ctxsize(struct crypto_alg *alg,
 						 int flags)
 {
 	unsigned int len = alg->cra_ctxsize;
 	switch (flags & CRYPTO_TFM_MODE_MASK) {
 	case CRYPTO_TFM_MODE_CBC:
 		len = ALIGN(len, (unsigned long)alg->cra_alignmask + 1);
 		len += alg->cra_blocksize;
 		break;
 	}
 	return len;
 }
 static inline unsigned int crypto_compress_ctxsize(struct crypto_alg *alg,
 						   int flags)
 {
 	return alg->cra_ctxsize;
 }
 struct crypto_alg *crypto_mod_get(struct crypto_alg *alg);
 void crypto_mod_put(struct crypto_alg *alg);
 struct crypto_alg *__crypto_alg_lookup(const char *name, u32 type, u32 mask);
 struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask);
 int crypto_init_digest_flags(struct crypto_tfm *tfm, u32 flags);
 int crypto_init_cipher_flags(struct crypto_tfm *tfm, u32 flags);
 int crypto_init_compress_flags(struct crypto_tfm *tfm, u32 flags);
 int crypto_init_digest_ops(struct crypto_tfm *tfm);
 int crypto_init_cipher_ops(struct crypto_tfm *tfm);
 int crypto_init_compress_ops(struct crypto_tfm *tfm);
 void crypto_exit_digest_ops(struct crypto_tfm *tfm);
 void crypto_exit_cipher_ops(struct crypto_tfm *tfm);
 void crypto_exit_compress_ops(struct crypto_tfm *tfm);
 void crypto_larval_error(const char *name, u32 type, u32 mask);
+void crypto_shoot_alg(struct crypto_alg *alg);
+struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 flags);
 int crypto_register_instance(struct crypto_template *tmpl,
 			     struct crypto_instance *inst);
 int crypto_register_notifier(struct notifier_block *nb);
 int crypto_unregister_notifier(struct notifier_block *nb);
+static inline void crypto_alg_put(struct crypto_alg *alg)
+{
+	if (atomic_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy)
+		alg->cra_destroy(alg);
+}
 static inline int crypto_tmpl_get(struct crypto_template *tmpl)
 {
 	return try_module_get(tmpl->module);
 }
 static inline void crypto_tmpl_put(struct crypto_template *tmpl)
 {
 	module_put(tmpl->module);
 }
 static inline int crypto_is_larval(struct crypto_alg *alg)
 {
 	return alg->cra_flags & CRYPTO_ALG_LARVAL;
+}
+static inline int crypto_is_dead(struct crypto_alg *alg)
+{
+	return alg->cra_flags & CRYPTO_ALG_DEAD;
+}
+static inline int crypto_is_moribund(struct crypto_alg *alg)
+{
+	return alg->cra_flags & (CRYPTO_ALG_DEAD | CRYPTO_ALG_DYING);
 }
 static inline int crypto_notify(unsigned long val, void *v)
 {
 	return blocking_notifier_call_chain(&crypto_chain, val, v);
 }
 #endif	/* _CRYPTO_INTERNAL_H */

include/crypto/algapi.h

Diff comments View file @ 6bfd480

 /*
  * Cryptographic API for algorithms (i.e., low-level API).
  *
  * Copyright (c) 2006 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_ALGAPI_H
 #define _CRYPTO_ALGAPI_H
 #include <linux/crypto.h>
 struct module;
 struct crypto_instance {
 	struct crypto_alg alg;
 	struct crypto_template *tmpl;
 	struct hlist_node list;
 	void *__ctx[] CRYPTO_MINALIGN_ATTR;
 };
 struct crypto_template {
 	struct list_head list;
 	struct hlist_head instances;
 	struct module *module;
 	struct crypto_instance *(*alloc)(void *param, unsigned int len);
 	void (*free)(struct crypto_instance *inst);
 	char name[CRYPTO_MAX_ALG_NAME];
 };
+struct crypto_spawn {
+	struct list_head list;
+	struct crypto_alg *alg;
+	struct crypto_instance *inst;
+};
 int crypto_register_template(struct crypto_template *tmpl);
 void crypto_unregister_template(struct crypto_template *tmpl);
 struct crypto_template *crypto_lookup_template(const char *name);
+int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
+		      struct crypto_instance *inst);
+void crypto_drop_spawn(struct crypto_spawn *spawn);
+struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn);
 static inline void *crypto_instance_ctx(struct crypto_instance *inst)
 {
 	return inst->__ctx;
 }
 #endif	/* _CRYPTO_ALGAPI_H */

include/linux/crypto.h

Diff comments View file @ 6bfd480

 /*
  * Scatterlist Cryptographic API.
  *
  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
  * Copyright (c) 2002 David S. Miller (davem@redhat.com)
  * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
  *
  * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
  * and Nettle, by Niels Möller.
  *
  * 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 _LINUX_CRYPTO_H
 #define _LINUX_CRYPTO_H
 #include <asm/atomic.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/uaccess.h>
 /*
  * Algorithm masks and types.
  */
 #define CRYPTO_ALG_TYPE_MASK		0x0000000f
 #define CRYPTO_ALG_TYPE_CIPHER		0x00000001
 #define CRYPTO_ALG_TYPE_DIGEST		0x00000002
 #define CRYPTO_ALG_TYPE_COMPRESS	0x00000004
 #define CRYPTO_ALG_LARVAL		0x00000010
+#define CRYPTO_ALG_DEAD			0x00000020
+#define CRYPTO_ALG_DYING		0x00000040
 /*
  * Transform masks and values (for crt_flags).
  */
 #define CRYPTO_TFM_MODE_MASK		0x000000ff
 #define CRYPTO_TFM_REQ_MASK		0x000fff00
 #define CRYPTO_TFM_RES_MASK		0xfff00000
 #define CRYPTO_TFM_MODE_ECB		0x00000001
 #define CRYPTO_TFM_MODE_CBC		0x00000002
 #define CRYPTO_TFM_MODE_CFB		0x00000004
 #define CRYPTO_TFM_MODE_CTR		0x00000008
 #define CRYPTO_TFM_REQ_WEAK_KEY		0x00000100
 #define CRYPTO_TFM_REQ_MAY_SLEEP	0x00000200
 #define CRYPTO_TFM_RES_WEAK_KEY		0x00100000
 #define CRYPTO_TFM_RES_BAD_KEY_LEN   	0x00200000
 #define CRYPTO_TFM_RES_BAD_KEY_SCHED 	0x00400000
 #define CRYPTO_TFM_RES_BAD_BLOCK_LEN 	0x00800000
 #define CRYPTO_TFM_RES_BAD_FLAGS 	0x01000000
 /*
  * Miscellaneous stuff.
  */
 #define CRYPTO_UNSPEC			0
 #define CRYPTO_MAX_ALG_NAME		64
 #define CRYPTO_DIR_ENCRYPT		1
 #define CRYPTO_DIR_DECRYPT		0
 /*
  * The macro CRYPTO_MINALIGN_ATTR (along with the void * type in the actual
  * declaration) is used to ensure that the crypto_tfm context structure is
  * aligned correctly for the given architecture so that there are no alignment
  * faults for C data types.  In particular, this is required on platforms such
  * as arm where pointers are 32-bit aligned but there are data types such as
  * u64 which require 64-bit alignment.
  */
 #if defined(ARCH_KMALLOC_MINALIGN)
 #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN
 #elif defined(ARCH_SLAB_MINALIGN)
 #define CRYPTO_MINALIGN ARCH_SLAB_MINALIGN
 #endif
 #ifdef CRYPTO_MINALIGN
 #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
 #else
 #define CRYPTO_MINALIGN_ATTR
 #endif
 struct scatterlist;
 struct crypto_tfm;
 struct cipher_desc {
 	struct crypto_tfm *tfm;
 	void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 	unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst,
 			     const u8 *src, unsigned int nbytes);
 	void *info;
 };
 /*
  * Algorithms: modular crypto algorithm implementations, managed
  * via crypto_register_alg() and crypto_unregister_alg().
  */
 struct cipher_alg {
 	unsigned int cia_min_keysize;
 	unsigned int cia_max_keysize;
 	int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key,
 	                  unsigned int keylen, u32 *flags);
 	void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 	void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
 	unsigned int (*cia_encrypt_ecb)(const struct cipher_desc *desc,
 					u8 *dst, const u8 *src,
 					unsigned int nbytes);
 	unsigned int (*cia_decrypt_ecb)(const struct cipher_desc *desc,
 					u8 *dst, const u8 *src,
 					unsigned int nbytes);
 	unsigned int (*cia_encrypt_cbc)(const struct cipher_desc *desc,
 					u8 *dst, const u8 *src,
 					unsigned int nbytes);
 	unsigned int (*cia_decrypt_cbc)(const struct cipher_desc *desc,
 					u8 *dst, const u8 *src,
 					unsigned int nbytes);
 };
 struct digest_alg {
 	unsigned int dia_digestsize;
 	void (*dia_init)(struct crypto_tfm *tfm);
 	void (*dia_update)(struct crypto_tfm *tfm, const u8 *data,
 			   unsigned int len);
 	void (*dia_final)(struct crypto_tfm *tfm, u8 *out);
 	int (*dia_setkey)(struct crypto_tfm *tfm, const u8 *key,
 	                  unsigned int keylen, u32 *flags);
 };
 struct compress_alg {
 	int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src,
 			    unsigned int slen, u8 *dst, unsigned int *dlen);
 	int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src,
 			      unsigned int slen, u8 *dst, unsigned int *dlen);
 };
 #define cra_cipher	cra_u.cipher
 #define cra_digest	cra_u.digest
 #define cra_compress	cra_u.compress
 struct crypto_alg {
 	struct list_head cra_list;
+	struct list_head cra_users;
 	u32 cra_flags;
 	unsigned int cra_blocksize;
 	unsigned int cra_ctxsize;
 	unsigned int cra_alignmask;
 	int cra_priority;
 	atomic_t cra_refcnt;
 	char cra_name[CRYPTO_MAX_ALG_NAME];
 	char cra_driver_name[CRYPTO_MAX_ALG_NAME];
 	union {
 		struct cipher_alg cipher;
 		struct digest_alg digest;
 		struct compress_alg compress;
 	} cra_u;
 	int (*cra_init)(struct crypto_tfm *tfm);
 	void (*cra_exit)(struct crypto_tfm *tfm);
 	void (*cra_destroy)(struct crypto_alg *alg);
 	struct module *cra_module;
 };
 /*
  * Algorithm registration interface.
  */
 int crypto_register_alg(struct crypto_alg *alg);
 int crypto_unregister_alg(struct crypto_alg *alg);
 /*
  * Algorithm query interface.
  */
 #ifdef CONFIG_CRYPTO
 int crypto_alg_available(const char *name, u32 flags);
 #else
 static inline int crypto_alg_available(const char *name, u32 flags)
 {
 	return 0;
 }
 #endif
 /*
  * Transforms: user-instantiated objects which encapsulate algorithms
  * and core processing logic.  Managed via crypto_alloc_tfm() and
  * crypto_free_tfm(), as well as the various helpers below.
  */
 struct cipher_tfm {
 	void *cit_iv;
 	unsigned int cit_ivsize;
 	u32 cit_mode;
 	int (*cit_setkey)(struct crypto_tfm *tfm,
 	                  const u8 *key, unsigned int keylen);
 	int (*cit_encrypt)(struct crypto_tfm *tfm,
 			   struct scatterlist *dst,
 			   struct scatterlist *src,
 			   unsigned int nbytes);
 	int (*cit_encrypt_iv)(struct crypto_tfm *tfm,
 	                      struct scatterlist *dst,
 	                      struct scatterlist *src,
 	                      unsigned int nbytes, u8 *iv);
 	int (*cit_decrypt)(struct crypto_tfm *tfm,
 			   struct scatterlist *dst,
 			   struct scatterlist *src,
 			   unsigned int nbytes);
 	int (*cit_decrypt_iv)(struct crypto_tfm *tfm,
 			   struct scatterlist *dst,
 			   struct scatterlist *src,
 			   unsigned int nbytes, u8 *iv);
 	void (*cit_xor_block)(u8 *dst, const u8 *src);
 };
 struct digest_tfm {
 	void (*dit_init)(struct crypto_tfm *tfm);
 	void (*dit_update)(struct crypto_tfm *tfm,
 	                   struct scatterlist *sg, unsigned int nsg);
 	void (*dit_final)(struct crypto_tfm *tfm, u8 *out);
 	void (*dit_digest)(struct crypto_tfm *tfm, struct scatterlist *sg,
 	                   unsigned int nsg, u8 *out);
 	int (*dit_setkey)(struct crypto_tfm *tfm,
 	                  const u8 *key, unsigned int keylen);
 #ifdef CONFIG_CRYPTO_HMAC
 	void *dit_hmac_block;
 #endif
 };
 struct compress_tfm {
 	int (*cot_compress)(struct crypto_tfm *tfm,
 	                    const u8 *src, unsigned int slen,
 	                    u8 *dst, unsigned int *dlen);
 	int (*cot_decompress)(struct crypto_tfm *tfm,
 	                      const u8 *src, unsigned int slen,
 	                      u8 *dst, unsigned int *dlen);
 };
 #define crt_cipher	crt_u.cipher
 #define crt_digest	crt_u.digest
 #define crt_compress	crt_u.compress
 struct crypto_tfm {
 	u32 crt_flags;
 	union {
 		struct cipher_tfm cipher;
 		struct digest_tfm digest;
 		struct compress_tfm compress;
 	} crt_u;
 	struct crypto_alg *__crt_alg;
 	void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
 };
 enum {
 	CRYPTOA_UNSPEC,
 	CRYPTOA_ALG,
 };
 struct crypto_attr_alg {
 	char name[CRYPTO_MAX_ALG_NAME];
 };
 /*
  * Transform user interface.
  */
 /*
  * crypto_alloc_tfm() will first attempt to locate an already loaded algorithm.
  * If that fails and the kernel supports dynamically loadable modules, it
  * will then attempt to load a module of the same name or alias.  A refcount
  * is grabbed on the algorithm which is then associated with the new transform.
  *
  * crypto_free_tfm() frees up the transform and any associated resources,
  * then drops the refcount on the associated algorithm.
  */
 struct crypto_tfm *crypto_alloc_tfm(const char *alg_name, u32 tfm_flags);
 void crypto_free_tfm(struct crypto_tfm *tfm);
 /*
  * Transform helpers which query the underlying algorithm.
  */
 static inline const char *crypto_tfm_alg_name(struct crypto_tfm *tfm)
 {
 	return tfm->__crt_alg->cra_name;
 }
 static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm)
 {
 	return module_name(tfm->__crt_alg->cra_module);
 }
 static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
 {
 	return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
 }
 static inline unsigned int crypto_tfm_alg_min_keysize(struct crypto_tfm *tfm)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	return tfm->__crt_alg->cra_cipher.cia_min_keysize;
 }
 static inline unsigned int crypto_tfm_alg_max_keysize(struct crypto_tfm *tfm)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	return tfm->__crt_alg->cra_cipher.cia_max_keysize;
 }
 static inline unsigned int crypto_tfm_alg_ivsize(struct crypto_tfm *tfm)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	return tfm->crt_cipher.cit_ivsize;
 }
 static inline unsigned int crypto_tfm_alg_blocksize(struct crypto_tfm *tfm)
 {
 	return tfm->__crt_alg->cra_blocksize;
 }
 static inline unsigned int crypto_tfm_alg_digestsize(struct crypto_tfm *tfm)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
 	return tfm->__crt_alg->cra_digest.dia_digestsize;
 }
 static inline unsigned int crypto_tfm_alg_alignmask(struct crypto_tfm *tfm)
 {
 	return tfm->__crt_alg->cra_alignmask;
 }
 static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm)
 {
 	return tfm->__crt_ctx;
 }
 static inline unsigned int crypto_tfm_ctx_alignment(void)
 {
 	struct crypto_tfm *tfm;
 	return __alignof__(tfm->__crt_ctx);
 }
 /*
  * API wrappers.
  */
 static inline void crypto_digest_init(struct crypto_tfm *tfm)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
 	tfm->crt_digest.dit_init(tfm);
 }
 static inline void crypto_digest_update(struct crypto_tfm *tfm,
                                         struct scatterlist *sg,
                                         unsigned int nsg)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
 	tfm->crt_digest.dit_update(tfm, sg, nsg);
 }
 static inline void crypto_digest_final(struct crypto_tfm *tfm, u8 *out)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
 	tfm->crt_digest.dit_final(tfm, out);
 }
 static inline void crypto_digest_digest(struct crypto_tfm *tfm,
                                         struct scatterlist *sg,
                                         unsigned int nsg, u8 *out)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
 	tfm->crt_digest.dit_digest(tfm, sg, nsg, out);
 }
 static inline int crypto_digest_setkey(struct crypto_tfm *tfm,
                                        const u8 *key, unsigned int keylen)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_DIGEST);
 	if (tfm->crt_digest.dit_setkey == NULL)
 		return -ENOSYS;
 	return tfm->crt_digest.dit_setkey(tfm, key, keylen);
 }
 static inline int crypto_cipher_setkey(struct crypto_tfm *tfm,
                                        const u8 *key, unsigned int keylen)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	return tfm->crt_cipher.cit_setkey(tfm, key, keylen);
 }
 static inline int crypto_cipher_encrypt(struct crypto_tfm *tfm,
                                         struct scatterlist *dst,
                                         struct scatterlist *src,
                                         unsigned int nbytes)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	return tfm->crt_cipher.cit_encrypt(tfm, dst, src, nbytes);
 }
 static inline int crypto_cipher_encrypt_iv(struct crypto_tfm *tfm,
                                            struct scatterlist *dst,
                                            struct scatterlist *src,
                                            unsigned int nbytes, u8 *iv)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	BUG_ON(tfm->crt_cipher.cit_mode == CRYPTO_TFM_MODE_ECB);
 	return tfm->crt_cipher.cit_encrypt_iv(tfm, dst, src, nbytes, iv);
 }
 static inline int crypto_cipher_decrypt(struct crypto_tfm *tfm,
                                         struct scatterlist *dst,
                                         struct scatterlist *src,
                                         unsigned int nbytes)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	return tfm->crt_cipher.cit_decrypt(tfm, dst, src, nbytes);
 }
 static inline int crypto_cipher_decrypt_iv(struct crypto_tfm *tfm,
                                            struct scatterlist *dst,
                                            struct scatterlist *src,
                                            unsigned int nbytes, u8 *iv)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	BUG_ON(tfm->crt_cipher.cit_mode == CRYPTO_TFM_MODE_ECB);
 	return tfm->crt_cipher.cit_decrypt_iv(tfm, dst, src, nbytes, iv);
 }
 static inline void crypto_cipher_set_iv(struct crypto_tfm *tfm,
                                         const u8 *src, unsigned int len)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	memcpy(tfm->crt_cipher.cit_iv, src, len);
 }
 static inline void crypto_cipher_get_iv(struct crypto_tfm *tfm,
                                         u8 *dst, unsigned int len)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_CIPHER);
 	memcpy(dst, tfm->crt_cipher.cit_iv, len);
 }
 static inline int crypto_comp_compress(struct crypto_tfm *tfm,
                                        const u8 *src, unsigned int slen,
                                        u8 *dst, unsigned int *dlen)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_COMPRESS);
 	return tfm->crt_compress.cot_compress(tfm, src, slen, dst, dlen);
 }
 static inline int crypto_comp_decompress(struct crypto_tfm *tfm,
                                          const u8 *src, unsigned int slen,
                                          u8 *dst, unsigned int *dlen)
 {
 	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_COMPRESS);
 	return tfm->crt_compress.cot_decompress(tfm, src, slen, dst, dlen);
 }
 /*
  * HMAC support.
  */
 #ifdef CONFIG_CRYPTO_HMAC
 void crypto_hmac_init(struct crypto_tfm *tfm, u8 *key, unsigned int *keylen);
 void crypto_hmac_update(struct crypto_tfm *tfm,
                         struct scatterlist *sg, unsigned int nsg);
 void crypto_hmac_final(struct crypto_tfm *tfm, u8 *key,
                        unsigned int *keylen, u8 *out);
 void crypto_hmac(struct crypto_tfm *tfm, u8 *key, unsigned int *keylen,
                  struct scatterlist *sg, unsigned int nsg, u8 *out);
 #endif	/* CONFIG_CRYPTO_HMAC */
 #endif	/* _LINUX_CRYPTO_H */