Commit | Line | Data |
---|---|---|
5068c7a8 SK |
1 | /* |
2 | * pcrypt - Parallel crypto wrapper. | |
3 | * | |
4 | * Copyright (C) 2009 secunet Security Networks AG | |
5 | * Copyright (C) 2009 Steffen Klassert <steffen.klassert@secunet.com> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify it | |
8 | * under the terms and conditions of the GNU General Public License, | |
9 | * version 2, as published by the Free Software Foundation. | |
10 | * | |
11 | * This program is distributed in the hope it will be useful, but WITHOUT | |
12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
14 | * more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License along with | |
17 | * this program; if not, write to the Free Software Foundation, Inc., | |
18 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | |
19 | */ | |
20 | ||
21 | #include <crypto/algapi.h> | |
22 | #include <crypto/internal/aead.h> | |
23 | #include <linux/err.h> | |
24 | #include <linux/init.h> | |
25 | #include <linux/module.h> | |
26 | #include <linux/slab.h> | |
e15bacbe | 27 | #include <linux/notifier.h> |
a3fb1e33 | 28 | #include <linux/kobject.h> |
5068c7a8 SK |
29 | #include <crypto/pcrypt.h> |
30 | ||
e15bacbe | 31 | struct pcrypt_instance { |
a3fb1e33 | 32 | const char *name; |
e15bacbe DK |
33 | struct padata_instance *pinst; |
34 | struct workqueue_struct *wq; | |
35 | ||
36 | /* | |
37 | * Cpumask for callback CPUs. It should be | |
38 | * equal to serial cpumask of corresponding padata instance, | |
39 | * so it is updated when padata notifies us about serial | |
40 | * cpumask change. | |
41 | * | |
42 | * cb_cpumask is protected by RCU. This fact prevents us from | |
43 | * using cpumask_var_t directly because the actual type of | |
44 | * cpumsak_var_t depends on kernel configuration(particularly on | |
45 | * CONFIG_CPUMASK_OFFSTACK macro). Depending on the configuration | |
46 | * cpumask_var_t may be either a pointer to the struct cpumask | |
47 | * or a variable allocated on the stack. Thus we can not safely use | |
48 | * cpumask_var_t with RCU operations such as rcu_assign_pointer or | |
49 | * rcu_dereference. So cpumask_var_t is wrapped with struct | |
50 | * pcrypt_cpumask which makes possible to use it with RCU. | |
51 | */ | |
52 | struct pcrypt_cpumask { | |
53 | cpumask_var_t mask; | |
54 | } *cb_cpumask; | |
55 | struct notifier_block nblock; | |
56 | }; | |
57 | ||
58 | static struct pcrypt_instance pencrypt; | |
59 | static struct pcrypt_instance pdecrypt; | |
a3fb1e33 | 60 | static struct kset *pcrypt_kset; |
5068c7a8 SK |
61 | |
62 | struct pcrypt_instance_ctx { | |
63 | struct crypto_spawn spawn; | |
64 | unsigned int tfm_count; | |
65 | }; | |
66 | ||
67 | struct pcrypt_aead_ctx { | |
68 | struct crypto_aead *child; | |
69 | unsigned int cb_cpu; | |
70 | }; | |
71 | ||
72 | static int pcrypt_do_parallel(struct padata_priv *padata, unsigned int *cb_cpu, | |
e15bacbe | 73 | struct pcrypt_instance *pcrypt) |
5068c7a8 SK |
74 | { |
75 | unsigned int cpu_index, cpu, i; | |
e15bacbe | 76 | struct pcrypt_cpumask *cpumask; |
5068c7a8 SK |
77 | |
78 | cpu = *cb_cpu; | |
79 | ||
e15bacbe DK |
80 | rcu_read_lock_bh(); |
81 | cpumask = rcu_dereference(pcrypt->cb_cpumask); | |
82 | if (cpumask_test_cpu(cpu, cpumask->mask)) | |
5068c7a8 SK |
83 | goto out; |
84 | ||
e15bacbe | 85 | cpu_index = cpu % cpumask_weight(cpumask->mask); |
5068c7a8 | 86 | |
e15bacbe | 87 | cpu = cpumask_first(cpumask->mask); |
5068c7a8 | 88 | for (i = 0; i < cpu_index; i++) |
e15bacbe | 89 | cpu = cpumask_next(cpu, cpumask->mask); |
5068c7a8 SK |
90 | |
91 | *cb_cpu = cpu; | |
92 | ||
93 | out: | |
e15bacbe DK |
94 | rcu_read_unlock_bh(); |
95 | return padata_do_parallel(pcrypt->pinst, padata, cpu); | |
5068c7a8 SK |
96 | } |
97 | ||
98 | static int pcrypt_aead_setkey(struct crypto_aead *parent, | |
99 | const u8 *key, unsigned int keylen) | |
100 | { | |
101 | struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(parent); | |
102 | ||
103 | return crypto_aead_setkey(ctx->child, key, keylen); | |
104 | } | |
105 | ||
106 | static int pcrypt_aead_setauthsize(struct crypto_aead *parent, | |
107 | unsigned int authsize) | |
108 | { | |
109 | struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(parent); | |
110 | ||
111 | return crypto_aead_setauthsize(ctx->child, authsize); | |
112 | } | |
113 | ||
114 | static void pcrypt_aead_serial(struct padata_priv *padata) | |
115 | { | |
116 | struct pcrypt_request *preq = pcrypt_padata_request(padata); | |
117 | struct aead_request *req = pcrypt_request_ctx(preq); | |
118 | ||
119 | aead_request_complete(req->base.data, padata->info); | |
120 | } | |
121 | ||
122 | static void pcrypt_aead_giv_serial(struct padata_priv *padata) | |
123 | { | |
124 | struct pcrypt_request *preq = pcrypt_padata_request(padata); | |
125 | struct aead_givcrypt_request *req = pcrypt_request_ctx(preq); | |
126 | ||
127 | aead_request_complete(req->areq.base.data, padata->info); | |
128 | } | |
129 | ||
130 | static void pcrypt_aead_done(struct crypto_async_request *areq, int err) | |
131 | { | |
132 | struct aead_request *req = areq->data; | |
133 | struct pcrypt_request *preq = aead_request_ctx(req); | |
134 | struct padata_priv *padata = pcrypt_request_padata(preq); | |
135 | ||
136 | padata->info = err; | |
137 | req->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; | |
138 | ||
139 | padata_do_serial(padata); | |
140 | } | |
141 | ||
142 | static void pcrypt_aead_enc(struct padata_priv *padata) | |
143 | { | |
144 | struct pcrypt_request *preq = pcrypt_padata_request(padata); | |
145 | struct aead_request *req = pcrypt_request_ctx(preq); | |
146 | ||
147 | padata->info = crypto_aead_encrypt(req); | |
148 | ||
5a1436be | 149 | if (padata->info == -EINPROGRESS) |
5068c7a8 SK |
150 | return; |
151 | ||
152 | padata_do_serial(padata); | |
153 | } | |
154 | ||
155 | static int pcrypt_aead_encrypt(struct aead_request *req) | |
156 | { | |
157 | int err; | |
158 | struct pcrypt_request *preq = aead_request_ctx(req); | |
159 | struct aead_request *creq = pcrypt_request_ctx(preq); | |
160 | struct padata_priv *padata = pcrypt_request_padata(preq); | |
161 | struct crypto_aead *aead = crypto_aead_reqtfm(req); | |
162 | struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(aead); | |
163 | u32 flags = aead_request_flags(req); | |
164 | ||
165 | memset(padata, 0, sizeof(struct padata_priv)); | |
166 | ||
167 | padata->parallel = pcrypt_aead_enc; | |
168 | padata->serial = pcrypt_aead_serial; | |
169 | ||
170 | aead_request_set_tfm(creq, ctx->child); | |
171 | aead_request_set_callback(creq, flags & ~CRYPTO_TFM_REQ_MAY_SLEEP, | |
172 | pcrypt_aead_done, req); | |
173 | aead_request_set_crypt(creq, req->src, req->dst, | |
174 | req->cryptlen, req->iv); | |
175 | aead_request_set_assoc(creq, req->assoc, req->assoclen); | |
176 | ||
e15bacbe | 177 | err = pcrypt_do_parallel(padata, &ctx->cb_cpu, &pencrypt); |
83f619f3 SK |
178 | if (!err) |
179 | return -EINPROGRESS; | |
5068c7a8 SK |
180 | |
181 | return err; | |
182 | } | |
183 | ||
184 | static void pcrypt_aead_dec(struct padata_priv *padata) | |
185 | { | |
186 | struct pcrypt_request *preq = pcrypt_padata_request(padata); | |
187 | struct aead_request *req = pcrypt_request_ctx(preq); | |
188 | ||
189 | padata->info = crypto_aead_decrypt(req); | |
190 | ||
5a1436be | 191 | if (padata->info == -EINPROGRESS) |
5068c7a8 SK |
192 | return; |
193 | ||
194 | padata_do_serial(padata); | |
195 | } | |
196 | ||
197 | static int pcrypt_aead_decrypt(struct aead_request *req) | |
198 | { | |
199 | int err; | |
200 | struct pcrypt_request *preq = aead_request_ctx(req); | |
201 | struct aead_request *creq = pcrypt_request_ctx(preq); | |
202 | struct padata_priv *padata = pcrypt_request_padata(preq); | |
203 | struct crypto_aead *aead = crypto_aead_reqtfm(req); | |
204 | struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(aead); | |
205 | u32 flags = aead_request_flags(req); | |
206 | ||
207 | memset(padata, 0, sizeof(struct padata_priv)); | |
208 | ||
209 | padata->parallel = pcrypt_aead_dec; | |
210 | padata->serial = pcrypt_aead_serial; | |
211 | ||
212 | aead_request_set_tfm(creq, ctx->child); | |
213 | aead_request_set_callback(creq, flags & ~CRYPTO_TFM_REQ_MAY_SLEEP, | |
214 | pcrypt_aead_done, req); | |
215 | aead_request_set_crypt(creq, req->src, req->dst, | |
216 | req->cryptlen, req->iv); | |
217 | aead_request_set_assoc(creq, req->assoc, req->assoclen); | |
218 | ||
e15bacbe | 219 | err = pcrypt_do_parallel(padata, &ctx->cb_cpu, &pdecrypt); |
83f619f3 SK |
220 | if (!err) |
221 | return -EINPROGRESS; | |
5068c7a8 SK |
222 | |
223 | return err; | |
224 | } | |
225 | ||
226 | static void pcrypt_aead_givenc(struct padata_priv *padata) | |
227 | { | |
228 | struct pcrypt_request *preq = pcrypt_padata_request(padata); | |
229 | struct aead_givcrypt_request *req = pcrypt_request_ctx(preq); | |
230 | ||
231 | padata->info = crypto_aead_givencrypt(req); | |
232 | ||
5a1436be | 233 | if (padata->info == -EINPROGRESS) |
5068c7a8 SK |
234 | return; |
235 | ||
236 | padata_do_serial(padata); | |
237 | } | |
238 | ||
239 | static int pcrypt_aead_givencrypt(struct aead_givcrypt_request *req) | |
240 | { | |
241 | int err; | |
242 | struct aead_request *areq = &req->areq; | |
243 | struct pcrypt_request *preq = aead_request_ctx(areq); | |
244 | struct aead_givcrypt_request *creq = pcrypt_request_ctx(preq); | |
245 | struct padata_priv *padata = pcrypt_request_padata(preq); | |
246 | struct crypto_aead *aead = aead_givcrypt_reqtfm(req); | |
247 | struct pcrypt_aead_ctx *ctx = crypto_aead_ctx(aead); | |
248 | u32 flags = aead_request_flags(areq); | |
249 | ||
250 | memset(padata, 0, sizeof(struct padata_priv)); | |
251 | ||
252 | padata->parallel = pcrypt_aead_givenc; | |
253 | padata->serial = pcrypt_aead_giv_serial; | |
254 | ||
255 | aead_givcrypt_set_tfm(creq, ctx->child); | |
256 | aead_givcrypt_set_callback(creq, flags & ~CRYPTO_TFM_REQ_MAY_SLEEP, | |
257 | pcrypt_aead_done, areq); | |
258 | aead_givcrypt_set_crypt(creq, areq->src, areq->dst, | |
259 | areq->cryptlen, areq->iv); | |
260 | aead_givcrypt_set_assoc(creq, areq->assoc, areq->assoclen); | |
261 | aead_givcrypt_set_giv(creq, req->giv, req->seq); | |
262 | ||
e15bacbe | 263 | err = pcrypt_do_parallel(padata, &ctx->cb_cpu, &pencrypt); |
83f619f3 SK |
264 | if (!err) |
265 | return -EINPROGRESS; | |
5068c7a8 SK |
266 | |
267 | return err; | |
268 | } | |
269 | ||
270 | static int pcrypt_aead_init_tfm(struct crypto_tfm *tfm) | |
271 | { | |
272 | int cpu, cpu_index; | |
273 | struct crypto_instance *inst = crypto_tfm_alg_instance(tfm); | |
274 | struct pcrypt_instance_ctx *ictx = crypto_instance_ctx(inst); | |
275 | struct pcrypt_aead_ctx *ctx = crypto_tfm_ctx(tfm); | |
276 | struct crypto_aead *cipher; | |
277 | ||
278 | ictx->tfm_count++; | |
279 | ||
280 | cpu_index = ictx->tfm_count % cpumask_weight(cpu_active_mask); | |
281 | ||
282 | ctx->cb_cpu = cpumask_first(cpu_active_mask); | |
283 | for (cpu = 0; cpu < cpu_index; cpu++) | |
284 | ctx->cb_cpu = cpumask_next(ctx->cb_cpu, cpu_active_mask); | |
285 | ||
286 | cipher = crypto_spawn_aead(crypto_instance_ctx(inst)); | |
287 | ||
288 | if (IS_ERR(cipher)) | |
289 | return PTR_ERR(cipher); | |
290 | ||
291 | ctx->child = cipher; | |
292 | tfm->crt_aead.reqsize = sizeof(struct pcrypt_request) | |
293 | + sizeof(struct aead_givcrypt_request) | |
294 | + crypto_aead_reqsize(cipher); | |
295 | ||
296 | return 0; | |
297 | } | |
298 | ||
299 | static void pcrypt_aead_exit_tfm(struct crypto_tfm *tfm) | |
300 | { | |
301 | struct pcrypt_aead_ctx *ctx = crypto_tfm_ctx(tfm); | |
302 | ||
303 | crypto_free_aead(ctx->child); | |
304 | } | |
305 | ||
306 | static struct crypto_instance *pcrypt_alloc_instance(struct crypto_alg *alg) | |
307 | { | |
308 | struct crypto_instance *inst; | |
309 | struct pcrypt_instance_ctx *ctx; | |
310 | int err; | |
311 | ||
312 | inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL); | |
313 | if (!inst) { | |
314 | inst = ERR_PTR(-ENOMEM); | |
315 | goto out; | |
316 | } | |
317 | ||
318 | err = -ENAMETOOLONG; | |
319 | if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, | |
320 | "pcrypt(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) | |
321 | goto out_free_inst; | |
322 | ||
323 | memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); | |
324 | ||
325 | ctx = crypto_instance_ctx(inst); | |
326 | err = crypto_init_spawn(&ctx->spawn, alg, inst, | |
327 | CRYPTO_ALG_TYPE_MASK); | |
328 | if (err) | |
329 | goto out_free_inst; | |
330 | ||
331 | inst->alg.cra_priority = alg->cra_priority + 100; | |
332 | inst->alg.cra_blocksize = alg->cra_blocksize; | |
333 | inst->alg.cra_alignmask = alg->cra_alignmask; | |
334 | ||
335 | out: | |
336 | return inst; | |
337 | ||
338 | out_free_inst: | |
339 | kfree(inst); | |
340 | inst = ERR_PTR(err); | |
341 | goto out; | |
342 | } | |
343 | ||
80a6d7db DC |
344 | static struct crypto_instance *pcrypt_alloc_aead(struct rtattr **tb, |
345 | u32 type, u32 mask) | |
5068c7a8 SK |
346 | { |
347 | struct crypto_instance *inst; | |
348 | struct crypto_alg *alg; | |
5068c7a8 | 349 | |
80a6d7db | 350 | alg = crypto_get_attr_alg(tb, type, (mask & CRYPTO_ALG_TYPE_MASK)); |
5068c7a8 SK |
351 | if (IS_ERR(alg)) |
352 | return ERR_CAST(alg); | |
353 | ||
354 | inst = pcrypt_alloc_instance(alg); | |
355 | if (IS_ERR(inst)) | |
356 | goto out_put_alg; | |
357 | ||
358 | inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD | CRYPTO_ALG_ASYNC; | |
359 | inst->alg.cra_type = &crypto_aead_type; | |
360 | ||
361 | inst->alg.cra_aead.ivsize = alg->cra_aead.ivsize; | |
362 | inst->alg.cra_aead.geniv = alg->cra_aead.geniv; | |
363 | inst->alg.cra_aead.maxauthsize = alg->cra_aead.maxauthsize; | |
364 | ||
365 | inst->alg.cra_ctxsize = sizeof(struct pcrypt_aead_ctx); | |
366 | ||
367 | inst->alg.cra_init = pcrypt_aead_init_tfm; | |
368 | inst->alg.cra_exit = pcrypt_aead_exit_tfm; | |
369 | ||
370 | inst->alg.cra_aead.setkey = pcrypt_aead_setkey; | |
371 | inst->alg.cra_aead.setauthsize = pcrypt_aead_setauthsize; | |
372 | inst->alg.cra_aead.encrypt = pcrypt_aead_encrypt; | |
373 | inst->alg.cra_aead.decrypt = pcrypt_aead_decrypt; | |
374 | inst->alg.cra_aead.givencrypt = pcrypt_aead_givencrypt; | |
375 | ||
376 | out_put_alg: | |
377 | crypto_mod_put(alg); | |
378 | return inst; | |
379 | } | |
380 | ||
381 | static struct crypto_instance *pcrypt_alloc(struct rtattr **tb) | |
382 | { | |
383 | struct crypto_attr_type *algt; | |
384 | ||
385 | algt = crypto_get_attr_type(tb); | |
386 | if (IS_ERR(algt)) | |
387 | return ERR_CAST(algt); | |
388 | ||
389 | switch (algt->type & algt->mask & CRYPTO_ALG_TYPE_MASK) { | |
390 | case CRYPTO_ALG_TYPE_AEAD: | |
80a6d7db | 391 | return pcrypt_alloc_aead(tb, algt->type, algt->mask); |
5068c7a8 SK |
392 | } |
393 | ||
394 | return ERR_PTR(-EINVAL); | |
395 | } | |
396 | ||
397 | static void pcrypt_free(struct crypto_instance *inst) | |
398 | { | |
399 | struct pcrypt_instance_ctx *ctx = crypto_instance_ctx(inst); | |
400 | ||
401 | crypto_drop_spawn(&ctx->spawn); | |
402 | kfree(inst); | |
403 | } | |
404 | ||
e15bacbe DK |
405 | static int pcrypt_cpumask_change_notify(struct notifier_block *self, |
406 | unsigned long val, void *data) | |
407 | { | |
408 | struct pcrypt_instance *pcrypt; | |
409 | struct pcrypt_cpumask *new_mask, *old_mask; | |
410 | ||
411 | if (!(val & PADATA_CPU_SERIAL)) | |
412 | return 0; | |
413 | ||
414 | pcrypt = container_of(self, struct pcrypt_instance, nblock); | |
415 | new_mask = kmalloc(sizeof(*new_mask), GFP_KERNEL); | |
416 | if (!new_mask) | |
417 | return -ENOMEM; | |
418 | if (!alloc_cpumask_var(&new_mask->mask, GFP_KERNEL)) { | |
419 | kfree(new_mask); | |
420 | return -ENOMEM; | |
421 | } | |
422 | ||
423 | old_mask = pcrypt->cb_cpumask; | |
424 | ||
425 | padata_get_cpumask(pcrypt->pinst, PADATA_CPU_SERIAL, new_mask->mask); | |
426 | rcu_assign_pointer(pcrypt->cb_cpumask, new_mask); | |
427 | synchronize_rcu_bh(); | |
428 | ||
429 | free_cpumask_var(old_mask->mask); | |
430 | kfree(old_mask); | |
431 | return 0; | |
432 | } | |
433 | ||
a3fb1e33 DK |
434 | static int pcrypt_sysfs_add(struct padata_instance *pinst, const char *name) |
435 | { | |
436 | int ret; | |
437 | ||
438 | pinst->kobj.kset = pcrypt_kset; | |
439 | ret = kobject_add(&pinst->kobj, NULL, name); | |
440 | if (!ret) | |
441 | kobject_uevent(&pinst->kobj, KOBJ_ADD); | |
442 | ||
443 | return ret; | |
444 | } | |
445 | ||
e15bacbe DK |
446 | static int __pcrypt_init_instance(struct pcrypt_instance *pcrypt, |
447 | const char *name) | |
448 | { | |
449 | int ret = -ENOMEM; | |
450 | struct pcrypt_cpumask *mask; | |
451 | ||
a3fb1e33 | 452 | pcrypt->name = name; |
e15bacbe DK |
453 | pcrypt->wq = create_workqueue(name); |
454 | if (!pcrypt->wq) | |
455 | goto err; | |
456 | ||
457 | pcrypt->pinst = padata_alloc(pcrypt->wq); | |
458 | if (!pcrypt->pinst) | |
459 | goto err_destroy_workqueue; | |
460 | ||
461 | mask = kmalloc(sizeof(*mask), GFP_KERNEL); | |
462 | if (!mask) | |
463 | goto err_free_padata; | |
464 | if (!alloc_cpumask_var(&mask->mask, GFP_KERNEL)) { | |
465 | kfree(mask); | |
466 | goto err_free_padata; | |
467 | } | |
468 | ||
469 | padata_get_cpumask(pcrypt->pinst, PADATA_CPU_SERIAL, mask->mask); | |
470 | rcu_assign_pointer(pcrypt->cb_cpumask, mask); | |
471 | ||
472 | pcrypt->nblock.notifier_call = pcrypt_cpumask_change_notify; | |
473 | ret = padata_register_cpumask_notifier(pcrypt->pinst, &pcrypt->nblock); | |
474 | if (ret) | |
475 | goto err_free_cpumask; | |
476 | ||
a3fb1e33 DK |
477 | ret = pcrypt_sysfs_add(pcrypt->pinst, name); |
478 | if (ret) | |
479 | goto err_unregister_notifier; | |
480 | ||
e15bacbe | 481 | return ret; |
a3fb1e33 DK |
482 | err_unregister_notifier: |
483 | padata_unregister_cpumask_notifier(pcrypt->pinst, &pcrypt->nblock); | |
e15bacbe DK |
484 | err_free_cpumask: |
485 | free_cpumask_var(mask->mask); | |
486 | kfree(mask); | |
487 | err_free_padata: | |
488 | padata_free(pcrypt->pinst); | |
489 | err_destroy_workqueue: | |
490 | destroy_workqueue(pcrypt->wq); | |
491 | err: | |
492 | return ret; | |
493 | } | |
494 | ||
495 | static void __pcrypt_deinit_instance(struct pcrypt_instance *pcrypt) | |
496 | { | |
a3fb1e33 | 497 | kobject_put(&pcrypt->pinst->kobj); |
e15bacbe DK |
498 | free_cpumask_var(pcrypt->cb_cpumask->mask); |
499 | kfree(pcrypt->cb_cpumask); | |
500 | ||
501 | padata_stop(pcrypt->pinst); | |
502 | padata_unregister_cpumask_notifier(pcrypt->pinst, &pcrypt->nblock); | |
503 | destroy_workqueue(pcrypt->wq); | |
504 | padata_free(pcrypt->pinst); | |
505 | } | |
506 | ||
5068c7a8 SK |
507 | static struct crypto_template pcrypt_tmpl = { |
508 | .name = "pcrypt", | |
509 | .alloc = pcrypt_alloc, | |
510 | .free = pcrypt_free, | |
511 | .module = THIS_MODULE, | |
512 | }; | |
513 | ||
514 | static int __init pcrypt_init(void) | |
515 | { | |
a3fb1e33 DK |
516 | int err = -ENOMEM; |
517 | ||
518 | pcrypt_kset = kset_create_and_add("pcrypt", NULL, kernel_kobj); | |
519 | if (!pcrypt_kset) | |
520 | goto err; | |
5068c7a8 | 521 | |
e15bacbe | 522 | err = __pcrypt_init_instance(&pencrypt, "pencrypt"); |
4c879170 | 523 | if (err) |
a3fb1e33 | 524 | goto err_unreg_kset; |
4c879170 | 525 | |
e15bacbe | 526 | err = __pcrypt_init_instance(&pdecrypt, "pdecrypt"); |
4c879170 | 527 | if (err) |
e15bacbe | 528 | goto err_deinit_pencrypt; |
4c879170 | 529 | |
e15bacbe DK |
530 | padata_start(pencrypt.pinst); |
531 | padata_start(pdecrypt.pinst); | |
5068c7a8 | 532 | |
e15bacbe | 533 | return crypto_register_template(&pcrypt_tmpl); |
5068c7a8 | 534 | |
e15bacbe DK |
535 | err_deinit_pencrypt: |
536 | __pcrypt_deinit_instance(&pencrypt); | |
a3fb1e33 DK |
537 | err_unreg_kset: |
538 | kset_unregister(pcrypt_kset); | |
5068c7a8 | 539 | err: |
4c879170 | 540 | return err; |
5068c7a8 SK |
541 | } |
542 | ||
543 | static void __exit pcrypt_exit(void) | |
544 | { | |
e15bacbe DK |
545 | __pcrypt_deinit_instance(&pencrypt); |
546 | __pcrypt_deinit_instance(&pdecrypt); | |
5068c7a8 | 547 | |
a3fb1e33 | 548 | kset_unregister(pcrypt_kset); |
5068c7a8 SK |
549 | crypto_unregister_template(&pcrypt_tmpl); |
550 | } | |
551 | ||
552 | module_init(pcrypt_init); | |
553 | module_exit(pcrypt_exit); | |
554 | ||
555 | MODULE_LICENSE("GPL"); | |
556 | MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>"); | |
557 | MODULE_DESCRIPTION("Parallel crypto wrapper"); |