pcrypt: Added sysfs interface to pcrypt
[linux-2.6.git] / crypto / pcrypt.c
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>
27 #include <linux/notifier.h>
28 #include <linux/kobject.h>
29 #include <crypto/pcrypt.h>
30
31 struct pcrypt_instance {
32         const char *name;
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;
60 static struct kset           *pcrypt_kset;
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,
73                               struct pcrypt_instance *pcrypt)
74 {
75         unsigned int cpu_index, cpu, i;
76         struct pcrypt_cpumask *cpumask;
77
78         cpu = *cb_cpu;
79
80         rcu_read_lock_bh();
81         cpumask = rcu_dereference(pcrypt->cb_cpumask);
82         if (cpumask_test_cpu(cpu, cpumask->mask))
83                         goto out;
84
85         cpu_index = cpu % cpumask_weight(cpumask->mask);
86
87         cpu = cpumask_first(cpumask->mask);
88         for (i = 0; i < cpu_index; i++)
89                 cpu = cpumask_next(cpu, cpumask->mask);
90
91         *cb_cpu = cpu;
92
93 out:
94         rcu_read_unlock_bh();
95         return padata_do_parallel(pcrypt->pinst, padata, cpu);
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
149         if (padata->info == -EINPROGRESS)
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
177         err = pcrypt_do_parallel(padata, &ctx->cb_cpu, &pencrypt);
178         if (!err)
179                 return -EINPROGRESS;
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
191         if (padata->info == -EINPROGRESS)
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
219         err = pcrypt_do_parallel(padata, &ctx->cb_cpu, &pdecrypt);
220         if (!err)
221                 return -EINPROGRESS;
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
233         if (padata->info == -EINPROGRESS)
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
263         err = pcrypt_do_parallel(padata, &ctx->cb_cpu, &pencrypt);
264         if (!err)
265                 return -EINPROGRESS;
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
344 static struct crypto_instance *pcrypt_alloc_aead(struct rtattr **tb,
345                                                  u32 type, u32 mask)
346 {
347         struct crypto_instance *inst;
348         struct crypto_alg *alg;
349
350         alg = crypto_get_attr_alg(tb, type, (mask & CRYPTO_ALG_TYPE_MASK));
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:
391                 return pcrypt_alloc_aead(tb, algt->type, algt->mask);
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
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
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
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
452         pcrypt->name = name;
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
477         ret = pcrypt_sysfs_add(pcrypt->pinst, name);
478         if (ret)
479                 goto err_unregister_notifier;
480
481         return ret;
482 err_unregister_notifier:
483         padata_unregister_cpumask_notifier(pcrypt->pinst, &pcrypt->nblock);
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 {
497         kobject_put(&pcrypt->pinst->kobj);
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
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 {
516         int err = -ENOMEM;
517
518         pcrypt_kset = kset_create_and_add("pcrypt", NULL, kernel_kobj);
519         if (!pcrypt_kset)
520                 goto err;
521
522         err = __pcrypt_init_instance(&pencrypt, "pencrypt");
523         if (err)
524                 goto err_unreg_kset;
525
526         err = __pcrypt_init_instance(&pdecrypt, "pdecrypt");
527         if (err)
528                 goto err_deinit_pencrypt;
529
530         padata_start(pencrypt.pinst);
531         padata_start(pdecrypt.pinst);
532
533         return crypto_register_template(&pcrypt_tmpl);
534
535 err_deinit_pencrypt:
536         __pcrypt_deinit_instance(&pencrypt);
537 err_unreg_kset:
538         kset_unregister(pcrypt_kset);
539 err:
540         return err;
541 }
542
543 static void __exit pcrypt_exit(void)
544 {
545         __pcrypt_deinit_instance(&pencrypt);
546         __pcrypt_deinit_instance(&pdecrypt);
547
548         kset_unregister(pcrypt_kset);
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");