ARM: qcom: add description of KPSS WDT for IPQ8064
[linux-2.6-microblaze.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/err.h>
14 #include <linux/errno.h>
15 #include <linux/init.h>
16 #include <linux/kernel.h>
17 #include <linux/list.h>
18 #include <linux/module.h>
19 #include <linux/rtnetlink.h>
20 #include <linux/slab.h>
21 #include <linux/string.h>
22
23 #include "internal.h"
24
25 static LIST_HEAD(crypto_template_list);
26
27 static inline int crypto_set_driver_name(struct crypto_alg *alg)
28 {
29         static const char suffix[] = "-generic";
30         char *driver_name = alg->cra_driver_name;
31         int len;
32
33         if (*driver_name)
34                 return 0;
35
36         len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
37         if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)
38                 return -ENAMETOOLONG;
39
40         memcpy(driver_name + len, suffix, sizeof(suffix));
41         return 0;
42 }
43
44 static inline void crypto_check_module_sig(struct module *mod)
45 {
46 #ifdef CONFIG_CRYPTO_FIPS
47         if (fips_enabled && mod && !mod->sig_ok)
48                 panic("Module %s signature verification failed in FIPS mode\n",
49                       mod->name);
50 #endif
51         return;
52 }
53
54 static int crypto_check_alg(struct crypto_alg *alg)
55 {
56         crypto_check_module_sig(alg->cra_module);
57
58         if (alg->cra_alignmask & (alg->cra_alignmask + 1))
59                 return -EINVAL;
60
61         if (alg->cra_blocksize > PAGE_SIZE / 8)
62                 return -EINVAL;
63
64         if (alg->cra_priority < 0)
65                 return -EINVAL;
66
67         atomic_set(&alg->cra_refcnt, 1);
68
69         return crypto_set_driver_name(alg);
70 }
71
72 static void crypto_destroy_instance(struct crypto_alg *alg)
73 {
74         struct crypto_instance *inst = (void *)alg;
75         struct crypto_template *tmpl = inst->tmpl;
76
77         tmpl->free(inst);
78         crypto_tmpl_put(tmpl);
79 }
80
81 static struct list_head *crypto_more_spawns(struct crypto_alg *alg,
82                                             struct list_head *stack,
83                                             struct list_head *top,
84                                             struct list_head *secondary_spawns)
85 {
86         struct crypto_spawn *spawn, *n;
87
88         if (list_empty(stack))
89                 return NULL;
90
91         spawn = list_first_entry(stack, struct crypto_spawn, list);
92         n = list_entry(spawn->list.next, struct crypto_spawn, list);
93
94         if (spawn->alg && &n->list != stack && !n->alg)
95                 n->alg = (n->list.next == stack) ? alg :
96                          &list_entry(n->list.next, struct crypto_spawn,
97                                      list)->inst->alg;
98
99         list_move(&spawn->list, secondary_spawns);
100
101         return &n->list == stack ? top : &n->inst->alg.cra_users;
102 }
103
104 static void crypto_remove_instance(struct crypto_instance *inst,
105                                    struct list_head *list)
106 {
107         struct crypto_template *tmpl = inst->tmpl;
108
109         if (crypto_is_dead(&inst->alg))
110                 return;
111
112         inst->alg.cra_flags |= CRYPTO_ALG_DEAD;
113         if (hlist_unhashed(&inst->list))
114                 return;
115
116         if (!tmpl || !crypto_tmpl_get(tmpl))
117                 return;
118
119         crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg);
120         list_move(&inst->alg.cra_list, list);
121         hlist_del(&inst->list);
122         inst->alg.cra_destroy = crypto_destroy_instance;
123
124         BUG_ON(!list_empty(&inst->alg.cra_users));
125 }
126
127 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
128                           struct crypto_alg *nalg)
129 {
130         u32 new_type = (nalg ?: alg)->cra_flags;
131         struct crypto_spawn *spawn, *n;
132         LIST_HEAD(secondary_spawns);
133         struct list_head *spawns;
134         LIST_HEAD(stack);
135         LIST_HEAD(top);
136
137         spawns = &alg->cra_users;
138         list_for_each_entry_safe(spawn, n, spawns, list) {
139                 if ((spawn->alg->cra_flags ^ new_type) & spawn->mask)
140                         continue;
141
142                 list_move(&spawn->list, &top);
143         }
144
145         spawns = &top;
146         do {
147                 while (!list_empty(spawns)) {
148                         struct crypto_instance *inst;
149
150                         spawn = list_first_entry(spawns, struct crypto_spawn,
151                                                  list);
152                         inst = spawn->inst;
153
154                         BUG_ON(&inst->alg == alg);
155
156                         list_move(&spawn->list, &stack);
157
158                         if (&inst->alg == nalg)
159                                 break;
160
161                         spawn->alg = NULL;
162                         spawns = &inst->alg.cra_users;
163                 }
164         } while ((spawns = crypto_more_spawns(alg, &stack, &top,
165                                               &secondary_spawns)));
166
167         list_for_each_entry_safe(spawn, n, &secondary_spawns, list) {
168                 if (spawn->alg)
169                         list_move(&spawn->list, &spawn->alg->cra_users);
170                 else
171                         crypto_remove_instance(spawn->inst, list);
172         }
173 }
174 EXPORT_SYMBOL_GPL(crypto_remove_spawns);
175
176 static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg)
177 {
178         struct crypto_alg *q;
179         struct crypto_larval *larval;
180         int ret = -EAGAIN;
181
182         if (crypto_is_dead(alg))
183                 goto err;
184
185         INIT_LIST_HEAD(&alg->cra_users);
186
187         /* No cheating! */
188         alg->cra_flags &= ~CRYPTO_ALG_TESTED;
189
190         ret = -EEXIST;
191
192         list_for_each_entry(q, &crypto_alg_list, cra_list) {
193                 if (q == alg)
194                         goto err;
195
196                 if (crypto_is_moribund(q))
197                         continue;
198
199                 if (crypto_is_larval(q)) {
200                         if (!strcmp(alg->cra_driver_name, q->cra_driver_name))
201                                 goto err;
202                         continue;
203                 }
204
205                 if (!strcmp(q->cra_driver_name, alg->cra_name) ||
206                     !strcmp(q->cra_name, alg->cra_driver_name))
207                         goto err;
208         }
209
210         larval = crypto_larval_alloc(alg->cra_name,
211                                      alg->cra_flags | CRYPTO_ALG_TESTED, 0);
212         if (IS_ERR(larval))
213                 goto out;
214
215         ret = -ENOENT;
216         larval->adult = crypto_mod_get(alg);
217         if (!larval->adult)
218                 goto free_larval;
219
220         atomic_set(&larval->alg.cra_refcnt, 1);
221         memcpy(larval->alg.cra_driver_name, alg->cra_driver_name,
222                CRYPTO_MAX_ALG_NAME);
223         larval->alg.cra_priority = alg->cra_priority;
224
225         list_add(&alg->cra_list, &crypto_alg_list);
226         list_add(&larval->alg.cra_list, &crypto_alg_list);
227
228 out:
229         return larval;
230
231 free_larval:
232         kfree(larval);
233 err:
234         larval = ERR_PTR(ret);
235         goto out;
236 }
237
238 void crypto_alg_tested(const char *name, int err)
239 {
240         struct crypto_larval *test;
241         struct crypto_alg *alg;
242         struct crypto_alg *q;
243         LIST_HEAD(list);
244
245         down_write(&crypto_alg_sem);
246         list_for_each_entry(q, &crypto_alg_list, cra_list) {
247                 if (crypto_is_moribund(q) || !crypto_is_larval(q))
248                         continue;
249
250                 test = (struct crypto_larval *)q;
251
252                 if (!strcmp(q->cra_driver_name, name))
253                         goto found;
254         }
255
256         printk(KERN_ERR "alg: Unexpected test result for %s: %d\n", name, err);
257         goto unlock;
258
259 found:
260         q->cra_flags |= CRYPTO_ALG_DEAD;
261         alg = test->adult;
262         if (err || list_empty(&alg->cra_list))
263                 goto complete;
264
265         alg->cra_flags |= CRYPTO_ALG_TESTED;
266
267         list_for_each_entry(q, &crypto_alg_list, cra_list) {
268                 if (q == alg)
269                         continue;
270
271                 if (crypto_is_moribund(q))
272                         continue;
273
274                 if (crypto_is_larval(q)) {
275                         struct crypto_larval *larval = (void *)q;
276
277                         /*
278                          * Check to see if either our generic name or
279                          * specific name can satisfy the name requested
280                          * by the larval entry q.
281                          */
282                         if (strcmp(alg->cra_name, q->cra_name) &&
283                             strcmp(alg->cra_driver_name, q->cra_name))
284                                 continue;
285
286                         if (larval->adult)
287                                 continue;
288                         if ((q->cra_flags ^ alg->cra_flags) & larval->mask)
289                                 continue;
290                         if (!crypto_mod_get(alg))
291                                 continue;
292
293                         larval->adult = alg;
294                         continue;
295                 }
296
297                 if (strcmp(alg->cra_name, q->cra_name))
298                         continue;
299
300                 if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&
301                     q->cra_priority > alg->cra_priority)
302                         continue;
303
304                 crypto_remove_spawns(q, &list, alg);
305         }
306
307 complete:
308         complete_all(&test->completion);
309
310 unlock:
311         up_write(&crypto_alg_sem);
312
313         crypto_remove_final(&list);
314 }
315 EXPORT_SYMBOL_GPL(crypto_alg_tested);
316
317 void crypto_remove_final(struct list_head *list)
318 {
319         struct crypto_alg *alg;
320         struct crypto_alg *n;
321
322         list_for_each_entry_safe(alg, n, list, cra_list) {
323                 list_del_init(&alg->cra_list);
324                 crypto_alg_put(alg);
325         }
326 }
327 EXPORT_SYMBOL_GPL(crypto_remove_final);
328
329 static void crypto_wait_for_test(struct crypto_larval *larval)
330 {
331         int err;
332
333         err = crypto_probing_notify(CRYPTO_MSG_ALG_REGISTER, larval->adult);
334         if (err != NOTIFY_STOP) {
335                 if (WARN_ON(err != NOTIFY_DONE))
336                         goto out;
337                 crypto_alg_tested(larval->alg.cra_driver_name, 0);
338         }
339
340         err = wait_for_completion_interruptible(&larval->completion);
341         WARN_ON(err);
342
343 out:
344         crypto_larval_kill(&larval->alg);
345 }
346
347 int crypto_register_alg(struct crypto_alg *alg)
348 {
349         struct crypto_larval *larval;
350         int err;
351
352         err = crypto_check_alg(alg);
353         if (err)
354                 return err;
355
356         down_write(&crypto_alg_sem);
357         larval = __crypto_register_alg(alg);
358         up_write(&crypto_alg_sem);
359
360         if (IS_ERR(larval))
361                 return PTR_ERR(larval);
362
363         crypto_wait_for_test(larval);
364         return 0;
365 }
366 EXPORT_SYMBOL_GPL(crypto_register_alg);
367
368 static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list)
369 {
370         if (unlikely(list_empty(&alg->cra_list)))
371                 return -ENOENT;
372
373         alg->cra_flags |= CRYPTO_ALG_DEAD;
374
375         crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg);
376         list_del_init(&alg->cra_list);
377         crypto_remove_spawns(alg, list, NULL);
378
379         return 0;
380 }
381
382 int crypto_unregister_alg(struct crypto_alg *alg)
383 {
384         int ret;
385         LIST_HEAD(list);
386
387         down_write(&crypto_alg_sem);
388         ret = crypto_remove_alg(alg, &list);
389         up_write(&crypto_alg_sem);
390
391         if (ret)
392                 return ret;
393
394         BUG_ON(atomic_read(&alg->cra_refcnt) != 1);
395         if (alg->cra_destroy)
396                 alg->cra_destroy(alg);
397
398         crypto_remove_final(&list);
399         return 0;
400 }
401 EXPORT_SYMBOL_GPL(crypto_unregister_alg);
402
403 int crypto_register_algs(struct crypto_alg *algs, int count)
404 {
405         int i, ret;
406
407         for (i = 0; i < count; i++) {
408                 ret = crypto_register_alg(&algs[i]);
409                 if (ret)
410                         goto err;
411         }
412
413         return 0;
414
415 err:
416         for (--i; i >= 0; --i)
417                 crypto_unregister_alg(&algs[i]);
418
419         return ret;
420 }
421 EXPORT_SYMBOL_GPL(crypto_register_algs);
422
423 int crypto_unregister_algs(struct crypto_alg *algs, int count)
424 {
425         int i, ret;
426
427         for (i = 0; i < count; i++) {
428                 ret = crypto_unregister_alg(&algs[i]);
429                 if (ret)
430                         pr_err("Failed to unregister %s %s: %d\n",
431                                algs[i].cra_driver_name, algs[i].cra_name, ret);
432         }
433
434         return 0;
435 }
436 EXPORT_SYMBOL_GPL(crypto_unregister_algs);
437
438 int crypto_register_template(struct crypto_template *tmpl)
439 {
440         struct crypto_template *q;
441         int err = -EEXIST;
442
443         down_write(&crypto_alg_sem);
444
445         crypto_check_module_sig(tmpl->module);
446
447         list_for_each_entry(q, &crypto_template_list, list) {
448                 if (q == tmpl)
449                         goto out;
450         }
451
452         list_add(&tmpl->list, &crypto_template_list);
453         crypto_notify(CRYPTO_MSG_TMPL_REGISTER, tmpl);
454         err = 0;
455 out:
456         up_write(&crypto_alg_sem);
457         return err;
458 }
459 EXPORT_SYMBOL_GPL(crypto_register_template);
460
461 void crypto_unregister_template(struct crypto_template *tmpl)
462 {
463         struct crypto_instance *inst;
464         struct hlist_node *n;
465         struct hlist_head *list;
466         LIST_HEAD(users);
467
468         down_write(&crypto_alg_sem);
469
470         BUG_ON(list_empty(&tmpl->list));
471         list_del_init(&tmpl->list);
472
473         list = &tmpl->instances;
474         hlist_for_each_entry(inst, list, list) {
475                 int err = crypto_remove_alg(&inst->alg, &users);
476
477                 BUG_ON(err);
478         }
479
480         crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER, tmpl);
481
482         up_write(&crypto_alg_sem);
483
484         hlist_for_each_entry_safe(inst, n, list, list) {
485                 BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1);
486                 tmpl->free(inst);
487         }
488         crypto_remove_final(&users);
489 }
490 EXPORT_SYMBOL_GPL(crypto_unregister_template);
491
492 static struct crypto_template *__crypto_lookup_template(const char *name)
493 {
494         struct crypto_template *q, *tmpl = NULL;
495
496         down_read(&crypto_alg_sem);
497         list_for_each_entry(q, &crypto_template_list, list) {
498                 if (strcmp(q->name, name))
499                         continue;
500                 if (unlikely(!crypto_tmpl_get(q)))
501                         continue;
502
503                 tmpl = q;
504                 break;
505         }
506         up_read(&crypto_alg_sem);
507
508         return tmpl;
509 }
510
511 struct crypto_template *crypto_lookup_template(const char *name)
512 {
513         return try_then_request_module(__crypto_lookup_template(name),
514                                        "crypto-%s", name);
515 }
516 EXPORT_SYMBOL_GPL(crypto_lookup_template);
517
518 int crypto_register_instance(struct crypto_template *tmpl,
519                              struct crypto_instance *inst)
520 {
521         struct crypto_larval *larval;
522         int err;
523
524         err = crypto_check_alg(&inst->alg);
525         if (err)
526                 return err;
527
528         inst->alg.cra_module = tmpl->module;
529         inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE;
530
531         if (unlikely(!crypto_mod_get(&inst->alg)))
532                 return -EAGAIN;
533
534         down_write(&crypto_alg_sem);
535
536         larval = __crypto_register_alg(&inst->alg);
537         if (IS_ERR(larval))
538                 goto unlock;
539
540         hlist_add_head(&inst->list, &tmpl->instances);
541         inst->tmpl = tmpl;
542
543 unlock:
544         up_write(&crypto_alg_sem);
545
546         err = PTR_ERR(larval);
547         if (IS_ERR(larval))
548                 goto err;
549
550         crypto_wait_for_test(larval);
551
552         /* Remove instance if test failed */
553         if (!(inst->alg.cra_flags & CRYPTO_ALG_TESTED))
554                 crypto_unregister_instance(inst);
555         err = 0;
556
557 err:
558         crypto_mod_put(&inst->alg);
559         return err;
560 }
561 EXPORT_SYMBOL_GPL(crypto_register_instance);
562
563 int crypto_unregister_instance(struct crypto_instance *inst)
564 {
565         LIST_HEAD(list);
566
567         down_write(&crypto_alg_sem);
568
569         crypto_remove_spawns(&inst->alg, &list, NULL);
570         crypto_remove_instance(inst, &list);
571
572         up_write(&crypto_alg_sem);
573
574         crypto_remove_final(&list);
575
576         return 0;
577 }
578 EXPORT_SYMBOL_GPL(crypto_unregister_instance);
579
580 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
581                       struct crypto_instance *inst, u32 mask)
582 {
583         int err = -EAGAIN;
584
585         spawn->inst = inst;
586         spawn->mask = mask;
587
588         down_write(&crypto_alg_sem);
589         if (!crypto_is_moribund(alg)) {
590                 list_add(&spawn->list, &alg->cra_users);
591                 spawn->alg = alg;
592                 err = 0;
593         }
594         up_write(&crypto_alg_sem);
595
596         return err;
597 }
598 EXPORT_SYMBOL_GPL(crypto_init_spawn);
599
600 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,
601                        struct crypto_instance *inst,
602                        const struct crypto_type *frontend)
603 {
604         int err = -EINVAL;
605
606         if ((alg->cra_flags ^ frontend->type) & frontend->maskset)
607                 goto out;
608
609         spawn->frontend = frontend;
610         err = crypto_init_spawn(spawn, alg, inst, frontend->maskset);
611
612 out:
613         return err;
614 }
615 EXPORT_SYMBOL_GPL(crypto_init_spawn2);
616
617 void crypto_drop_spawn(struct crypto_spawn *spawn)
618 {
619         if (!spawn->alg)
620                 return;
621
622         down_write(&crypto_alg_sem);
623         list_del(&spawn->list);
624         up_write(&crypto_alg_sem);
625 }
626 EXPORT_SYMBOL_GPL(crypto_drop_spawn);
627
628 static struct crypto_alg *crypto_spawn_alg(struct crypto_spawn *spawn)
629 {
630         struct crypto_alg *alg;
631         struct crypto_alg *alg2;
632
633         down_read(&crypto_alg_sem);
634         alg = spawn->alg;
635         alg2 = alg;
636         if (alg2)
637                 alg2 = crypto_mod_get(alg2);
638         up_read(&crypto_alg_sem);
639
640         if (!alg2) {
641                 if (alg)
642                         crypto_shoot_alg(alg);
643                 return ERR_PTR(-EAGAIN);
644         }
645
646         return alg;
647 }
648
649 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
650                                     u32 mask)
651 {
652         struct crypto_alg *alg;
653         struct crypto_tfm *tfm;
654
655         alg = crypto_spawn_alg(spawn);
656         if (IS_ERR(alg))
657                 return ERR_CAST(alg);
658
659         tfm = ERR_PTR(-EINVAL);
660         if (unlikely((alg->cra_flags ^ type) & mask))
661                 goto out_put_alg;
662
663         tfm = __crypto_alloc_tfm(alg, type, mask);
664         if (IS_ERR(tfm))
665                 goto out_put_alg;
666
667         return tfm;
668
669 out_put_alg:
670         crypto_mod_put(alg);
671         return tfm;
672 }
673 EXPORT_SYMBOL_GPL(crypto_spawn_tfm);
674
675 void *crypto_spawn_tfm2(struct crypto_spawn *spawn)
676 {
677         struct crypto_alg *alg;
678         struct crypto_tfm *tfm;
679
680         alg = crypto_spawn_alg(spawn);
681         if (IS_ERR(alg))
682                 return ERR_CAST(alg);
683
684         tfm = crypto_create_tfm(alg, spawn->frontend);
685         if (IS_ERR(tfm))
686                 goto out_put_alg;
687
688         return tfm;
689
690 out_put_alg:
691         crypto_mod_put(alg);
692         return tfm;
693 }
694 EXPORT_SYMBOL_GPL(crypto_spawn_tfm2);
695
696 int crypto_register_notifier(struct notifier_block *nb)
697 {
698         return blocking_notifier_chain_register(&crypto_chain, nb);
699 }
700 EXPORT_SYMBOL_GPL(crypto_register_notifier);
701
702 int crypto_unregister_notifier(struct notifier_block *nb)
703 {
704         return blocking_notifier_chain_unregister(&crypto_chain, nb);
705 }
706 EXPORT_SYMBOL_GPL(crypto_unregister_notifier);
707
708 struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb)
709 {
710         struct rtattr *rta = tb[0];
711         struct crypto_attr_type *algt;
712
713         if (!rta)
714                 return ERR_PTR(-ENOENT);
715         if (RTA_PAYLOAD(rta) < sizeof(*algt))
716                 return ERR_PTR(-EINVAL);
717         if (rta->rta_type != CRYPTOA_TYPE)
718                 return ERR_PTR(-EINVAL);
719
720         algt = RTA_DATA(rta);
721
722         return algt;
723 }
724 EXPORT_SYMBOL_GPL(crypto_get_attr_type);
725
726 int crypto_check_attr_type(struct rtattr **tb, u32 type)
727 {
728         struct crypto_attr_type *algt;
729
730         algt = crypto_get_attr_type(tb);
731         if (IS_ERR(algt))
732                 return PTR_ERR(algt);
733
734         if ((algt->type ^ type) & algt->mask)
735                 return -EINVAL;
736
737         return 0;
738 }
739 EXPORT_SYMBOL_GPL(crypto_check_attr_type);
740
741 const char *crypto_attr_alg_name(struct rtattr *rta)
742 {
743         struct crypto_attr_alg *alga;
744
745         if (!rta)
746                 return ERR_PTR(-ENOENT);
747         if (RTA_PAYLOAD(rta) < sizeof(*alga))
748                 return ERR_PTR(-EINVAL);
749         if (rta->rta_type != CRYPTOA_ALG)
750                 return ERR_PTR(-EINVAL);
751
752         alga = RTA_DATA(rta);
753         alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0;
754
755         return alga->name;
756 }
757 EXPORT_SYMBOL_GPL(crypto_attr_alg_name);
758
759 struct crypto_alg *crypto_attr_alg2(struct rtattr *rta,
760                                     const struct crypto_type *frontend,
761                                     u32 type, u32 mask)
762 {
763         const char *name;
764
765         name = crypto_attr_alg_name(rta);
766         if (IS_ERR(name))
767                 return ERR_CAST(name);
768
769         return crypto_find_alg(name, frontend, type, mask);
770 }
771 EXPORT_SYMBOL_GPL(crypto_attr_alg2);
772
773 int crypto_attr_u32(struct rtattr *rta, u32 *num)
774 {
775         struct crypto_attr_u32 *nu32;
776
777         if (!rta)
778                 return -ENOENT;
779         if (RTA_PAYLOAD(rta) < sizeof(*nu32))
780                 return -EINVAL;
781         if (rta->rta_type != CRYPTOA_U32)
782                 return -EINVAL;
783
784         nu32 = RTA_DATA(rta);
785         *num = nu32->num;
786
787         return 0;
788 }
789 EXPORT_SYMBOL_GPL(crypto_attr_u32);
790
791 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg,
792                              unsigned int head)
793 {
794         struct crypto_instance *inst;
795         char *p;
796         int err;
797
798         p = kzalloc(head + sizeof(*inst) + sizeof(struct crypto_spawn),
799                     GFP_KERNEL);
800         if (!p)
801                 return ERR_PTR(-ENOMEM);
802
803         inst = (void *)(p + head);
804
805         err = -ENAMETOOLONG;
806         if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name,
807                      alg->cra_name) >= CRYPTO_MAX_ALG_NAME)
808                 goto err_free_inst;
809
810         if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)",
811                      name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
812                 goto err_free_inst;
813
814         return p;
815
816 err_free_inst:
817         kfree(p);
818         return ERR_PTR(err);
819 }
820 EXPORT_SYMBOL_GPL(crypto_alloc_instance2);
821
822 struct crypto_instance *crypto_alloc_instance(const char *name,
823                                               struct crypto_alg *alg)
824 {
825         struct crypto_instance *inst;
826         struct crypto_spawn *spawn;
827         int err;
828
829         inst = crypto_alloc_instance2(name, alg, 0);
830         if (IS_ERR(inst))
831                 goto out;
832
833         spawn = crypto_instance_ctx(inst);
834         err = crypto_init_spawn(spawn, alg, inst,
835                                 CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);
836
837         if (err)
838                 goto err_free_inst;
839
840         return inst;
841
842 err_free_inst:
843         kfree(inst);
844         inst = ERR_PTR(err);
845
846 out:
847         return inst;
848 }
849 EXPORT_SYMBOL_GPL(crypto_alloc_instance);
850
851 void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen)
852 {
853         INIT_LIST_HEAD(&queue->list);
854         queue->backlog = &queue->list;
855         queue->qlen = 0;
856         queue->max_qlen = max_qlen;
857 }
858 EXPORT_SYMBOL_GPL(crypto_init_queue);
859
860 int crypto_enqueue_request(struct crypto_queue *queue,
861                            struct crypto_async_request *request)
862 {
863         int err = -EINPROGRESS;
864
865         if (unlikely(queue->qlen >= queue->max_qlen)) {
866                 err = -EBUSY;
867                 if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG))
868                         goto out;
869                 if (queue->backlog == &queue->list)
870                         queue->backlog = &request->list;
871         }
872
873         queue->qlen++;
874         list_add_tail(&request->list, &queue->list);
875
876 out:
877         return err;
878 }
879 EXPORT_SYMBOL_GPL(crypto_enqueue_request);
880
881 void *__crypto_dequeue_request(struct crypto_queue *queue, unsigned int offset)
882 {
883         struct list_head *request;
884
885         if (unlikely(!queue->qlen))
886                 return NULL;
887
888         queue->qlen--;
889
890         if (queue->backlog != &queue->list)
891                 queue->backlog = queue->backlog->next;
892
893         request = queue->list.next;
894         list_del(request);
895
896         return (char *)list_entry(request, struct crypto_async_request, list) -
897                offset;
898 }
899 EXPORT_SYMBOL_GPL(__crypto_dequeue_request);
900
901 struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue)
902 {
903         return __crypto_dequeue_request(queue, 0);
904 }
905 EXPORT_SYMBOL_GPL(crypto_dequeue_request);
906
907 int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm)
908 {
909         struct crypto_async_request *req;
910
911         list_for_each_entry(req, &queue->list, list) {
912                 if (req->tfm == tfm)
913                         return 1;
914         }
915
916         return 0;
917 }
918 EXPORT_SYMBOL_GPL(crypto_tfm_in_queue);
919
920 static inline void crypto_inc_byte(u8 *a, unsigned int size)
921 {
922         u8 *b = (a + size);
923         u8 c;
924
925         for (; size; size--) {
926                 c = *--b + 1;
927                 *b = c;
928                 if (c)
929                         break;
930         }
931 }
932
933 void crypto_inc(u8 *a, unsigned int size)
934 {
935         __be32 *b = (__be32 *)(a + size);
936         u32 c;
937
938         for (; size >= 4; size -= 4) {
939                 c = be32_to_cpu(*--b) + 1;
940                 *b = cpu_to_be32(c);
941                 if (c)
942                         return;
943         }
944
945         crypto_inc_byte(a, size);
946 }
947 EXPORT_SYMBOL_GPL(crypto_inc);
948
949 static inline void crypto_xor_byte(u8 *a, const u8 *b, unsigned int size)
950 {
951         for (; size; size--)
952                 *a++ ^= *b++;
953 }
954
955 void crypto_xor(u8 *dst, const u8 *src, unsigned int size)
956 {
957         u32 *a = (u32 *)dst;
958         u32 *b = (u32 *)src;
959
960         for (; size >= 4; size -= 4)
961                 *a++ ^= *b++;
962
963         crypto_xor_byte((u8 *)a, (u8 *)b, size);
964 }
965 EXPORT_SYMBOL_GPL(crypto_xor);
966
967 static int __init crypto_algapi_init(void)
968 {
969         crypto_init_proc();
970         return 0;
971 }
972
973 static void __exit crypto_algapi_exit(void)
974 {
975         crypto_exit_proc();
976 }
977
978 module_init(crypto_algapi_init);
979 module_exit(crypto_algapi_exit);
980
981 MODULE_LICENSE("GPL");
982 MODULE_DESCRIPTION("Cryptographic algorithms API");