[CRYPTO] api: Add template registration
[linux-2.6.git] / crypto / algapi.c
1 /*
2  * Cryptographic API for algorithms (i.e., low-level API).
3  *
4  * Copyright (c) 2006 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 #include <linux/errno.h>
14 #include <linux/init.h>
15 #include <linux/kernel.h>
16 #include <linux/list.h>
17 #include <linux/module.h>
18 #include <linux/string.h>
19
20 #include "internal.h"
21
22 static LIST_HEAD(crypto_template_list);
23
24 static inline int crypto_set_driver_name(struct crypto_alg *alg)
25 {
26         static const char suffix[] = "-generic";
27         char *driver_name = alg->cra_driver_name;
28         int len;
29
30         if (*driver_name)
31                 return 0;
32
33         len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
34         if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)
35                 return -ENAMETOOLONG;
36
37         memcpy(driver_name + len, suffix, sizeof(suffix));
38         return 0;
39 }
40
41 static int crypto_check_alg(struct crypto_alg *alg)
42 {
43         if (alg->cra_alignmask & (alg->cra_alignmask + 1))
44                 return -EINVAL;
45
46         if (alg->cra_alignmask & alg->cra_blocksize)
47                 return -EINVAL;
48
49         if (alg->cra_blocksize > PAGE_SIZE / 8)
50                 return -EINVAL;
51
52         if (alg->cra_priority < 0)
53                 return -EINVAL;
54
55         return crypto_set_driver_name(alg);
56 }
57
58 static int __crypto_register_alg(struct crypto_alg *alg)
59 {
60         struct crypto_alg *q;
61         int ret = -EEXIST;
62
63         list_for_each_entry(q, &crypto_alg_list, cra_list) {
64                 if (q == alg)
65                         goto out;
66         }
67         
68         list_add(&alg->cra_list, &crypto_alg_list);
69         atomic_set(&alg->cra_refcnt, 1);
70         ret = 0;
71 out:    
72         return ret;
73 }
74
75 int crypto_register_alg(struct crypto_alg *alg)
76 {
77         int err;
78
79         err = crypto_check_alg(alg);
80         if (err)
81                 return err;
82
83         down_write(&crypto_alg_sem);
84         err = __crypto_register_alg(alg);
85         up_write(&crypto_alg_sem);
86
87         return err;
88 }
89 EXPORT_SYMBOL_GPL(crypto_register_alg);
90
91 int crypto_unregister_alg(struct crypto_alg *alg)
92 {
93         int ret = -ENOENT;
94         
95         down_write(&crypto_alg_sem);
96         if (likely(!list_empty(&alg->cra_list))) {
97                 list_del_init(&alg->cra_list);
98                 ret = 0;
99         }
100         up_write(&crypto_alg_sem);
101
102         if (ret)
103                 return ret;
104
105         BUG_ON(atomic_read(&alg->cra_refcnt) != 1);
106         if (alg->cra_destroy)
107                 alg->cra_destroy(alg);
108
109         return 0;
110 }
111 EXPORT_SYMBOL_GPL(crypto_unregister_alg);
112
113 int crypto_register_template(struct crypto_template *tmpl)
114 {
115         struct crypto_template *q;
116         int err = -EEXIST;
117
118         down_write(&crypto_alg_sem);
119
120         list_for_each_entry(q, &crypto_template_list, list) {
121                 if (q == tmpl)
122                         goto out;
123         }
124
125         list_add(&tmpl->list, &crypto_template_list);
126         err = 0;
127 out:
128         up_write(&crypto_alg_sem);
129         return err;
130 }
131 EXPORT_SYMBOL_GPL(crypto_register_template);
132
133 void crypto_unregister_template(struct crypto_template *tmpl)
134 {
135         struct crypto_instance *inst;
136         struct hlist_node *p, *n;
137         struct hlist_head *list;
138
139         down_write(&crypto_alg_sem);
140
141         BUG_ON(list_empty(&tmpl->list));
142         list_del_init(&tmpl->list);
143
144         list = &tmpl->instances;
145         hlist_for_each_entry(inst, p, list, list) {
146                 BUG_ON(list_empty(&inst->alg.cra_list));
147                 list_del_init(&inst->alg.cra_list);
148         }
149
150         up_write(&crypto_alg_sem);
151
152         hlist_for_each_entry_safe(inst, p, n, list, list) {
153                 BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1);
154                 tmpl->free(inst);
155         }
156 }
157 EXPORT_SYMBOL_GPL(crypto_unregister_template);
158
159 static struct crypto_template *__crypto_lookup_template(const char *name)
160 {
161         struct crypto_template *q, *tmpl = NULL;
162
163         down_read(&crypto_alg_sem);
164         list_for_each_entry(q, &crypto_template_list, list) {
165                 if (strcmp(q->name, name))
166                         continue;
167                 if (unlikely(!crypto_tmpl_get(q)))
168                         continue;
169
170                 tmpl = q;
171                 break;
172         }
173         up_read(&crypto_alg_sem);
174
175         return tmpl;
176 }
177
178 struct crypto_template *crypto_lookup_template(const char *name)
179 {
180         return try_then_request_module(__crypto_lookup_template(name), name);
181 }
182 EXPORT_SYMBOL_GPL(crypto_lookup_template);
183
184 int crypto_register_instance(struct crypto_template *tmpl,
185                              struct crypto_instance *inst)
186 {
187         int err = -EINVAL;
188
189         if (inst->alg.cra_destroy)
190                 goto err;
191
192         err = crypto_check_alg(&inst->alg);
193         if (err)
194                 goto err;
195
196         inst->alg.cra_module = tmpl->module;
197
198         down_write(&crypto_alg_sem);
199
200         err = __crypto_register_alg(&inst->alg);
201         if (err)
202                 goto unlock;
203
204         hlist_add_head(&inst->list, &tmpl->instances);
205         inst->tmpl = tmpl;
206
207 unlock:
208         up_write(&crypto_alg_sem);
209
210 err:
211         return err;
212 }
213 EXPORT_SYMBOL_GPL(crypto_register_instance);
214
215 static int __init crypto_algapi_init(void)
216 {
217         crypto_init_proc();
218         return 0;
219 }
220
221 static void __exit crypto_algapi_exit(void)
222 {
223         crypto_exit_proc();
224 }
225
226 module_init(crypto_algapi_init);
227 module_exit(crypto_algapi_exit);
228
229 MODULE_LICENSE("GPL");
230 MODULE_DESCRIPTION("Cryptographic algorithms API");