?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
code style scripts/checkpatch.pl (linux-3.9-rc1) formatting
[linux-2.6.32.60-moxart.git] / crypto / tcrypt.c
blobaa3f84ccc78632ca241f0cc87d14c6a98444f946
1 /*
2 * Quick & dirty crypto testing module.
3 *
4 * This will only exist until we have a better testing mechanism
5 * (e.g. a char device).
6 *
7 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
8 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
9 * Copyright (c) 2007 Nokia Siemens Networks
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the Free
13 * Software Foundation; either version 2 of the License, or (at your option)
14 * any later version.
15 *
16 */
17
18 #include <crypto/hash.h>
19 #include <linux/err.h>
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/scatterlist.h>
24 #include <linux/string.h>
25 #include <linux/moduleparam.h>
26 #include <linux/jiffies.h>
27 #include <linux/timex.h>
28 #include <linux/interrupt.h>
29 #include "tcrypt.h"
30 #include "internal.h"
31
32 /*
33 * Need slab memory for testing (size in number of pages).
34 */
35 #define TVMEMSIZE 4
36
37 /*
38 * Used by test_cipher_speed()
39 */
40 #define ENCRYPT 1
41 #define DECRYPT 0
42
43 /*
44 * Used by test_cipher_speed()
45 */
46 static unsigned int sec;
47
48 static char *alg = NULL;
49 static u32 type;
50 static u32 mask;
51 static int mode;
52 static char *tvmem[TVMEMSIZE];
53
54 static char *check[] = {
55 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
56 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
57 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
58 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
59 "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
60 "lzo", "cts", "zlib", NULL
61 };
62
63 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
64 struct scatterlist *sg, int blen, int sec)
65 {
66 unsigned long start, end;
67 int bcount;
68 int ret;
69
70 for (start = jiffies, end = start + sec * HZ, bcount = 0;
71 time_before(jiffies, end); bcount++) {
72 if (enc)
73 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
74 else
75 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
76
77 if (ret)
78 return ret;
79 }
80
81 printk("%d operations in %d seconds (%ld bytes)\n",
82 bcount, sec, (long)bcount * blen);
83 return 0;
84 }
85
86 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
87 struct scatterlist *sg, int blen)
88 {
89 unsigned long cycles = 0;
90 int ret = 0;
91 int i;
92
93 local_bh_disable();
94 local_irq_disable();
95
96 /* Warm-up run. */
97 for (i = 0; i < 4; i++) {
98 if (enc)
99 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
100 else
101 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
102
103 if (ret)
104 goto out;
105 }
106
107 /* The real thing. */
108 for (i = 0; i < 8; i++) {
109 cycles_t start, end;
110
111 start = get_cycles();
112 if (enc)
113 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
114 else
115 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
116 end = get_cycles();
117
118 if (ret)
119 goto out;
120
121 cycles += end - start;
122 }
123
124 out:
125 local_irq_enable();
126 local_bh_enable();
127
128 if (ret == 0)
129 printk("1 operation in %lu cycles (%d bytes)\n",
130 (cycles + 4) / 8, blen);
131
132 return ret;
133 }
134
135 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
136
137 static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
138 struct cipher_speed_template *template,
139 unsigned int tcount, u8 *keysize)
140 {
141 unsigned int ret, i, j, iv_len;
142 const char *key, iv[128];
143 struct crypto_blkcipher *tfm;
144 struct blkcipher_desc desc;
145 const char *e;
146 u32 *b_size;
147
148 if (enc == ENCRYPT)
149 e = "encryption";
150 else
151 e = "decryption";
152
153 printk("\ntesting speed of %s %s\n", algo, e);
154
155 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
156
157 if (IS_ERR(tfm)) {
158 printk("failed to load transform for %s: %ld\n", algo,
159 PTR_ERR(tfm));
160 return;
161 }
162 desc.tfm = tfm;
163 desc.flags = 0;
164
165 i = 0;
166 do {
167
168 b_size = block_sizes;
169 do {
170 struct scatterlist sg[TVMEMSIZE];
171
172 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
173 printk("template (%u) too big for "
174 "tvmem (%lu)\n", *keysize + *b_size,
175 TVMEMSIZE * PAGE_SIZE);
176 goto out;
177 }
178
179 printk("test %u (%d bit key, %d byte blocks): ", i,
180 *keysize * 8, *b_size);
181
182 memset(tvmem[0], 0xff, PAGE_SIZE);
183
184 /* set key, plain text and IV */
185 key = tvmem[0];
186 for (j = 0; j < tcount; j++) {
187 if (template[j].klen == *keysize) {
188 key = template[j].key;
189 break;
190 }
191 }
192
193 ret = crypto_blkcipher_setkey(tfm, key, *keysize);
194 if (ret) {
195 printk("setkey() failed flags=%x\n",
196 crypto_blkcipher_get_flags(tfm));
197 goto out;
198 }
199
200 sg_init_table(sg, TVMEMSIZE);
201 sg_set_buf(sg, tvmem[0] + *keysize,
202 PAGE_SIZE - *keysize);
203 for (j = 1; j < TVMEMSIZE; j++) {
204 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
205 memset (tvmem[j], 0xff, PAGE_SIZE);
206 }
207
208 iv_len = crypto_blkcipher_ivsize(tfm);
209 if (iv_len) {
210 memset(&iv, 0xff, iv_len);
211 crypto_blkcipher_set_iv(tfm, iv, iv_len);
212 }
213
214 if (sec)
215 ret = test_cipher_jiffies(&desc, enc, sg,
216 *b_size, sec);
217 else
218 ret = test_cipher_cycles(&desc, enc, sg,
219 *b_size);
220
221 if (ret) {
222 printk("%s() failed flags=%x\n", e, desc.flags);
223 break;
224 }
225 b_size++;
226 i++;
227 } while (*b_size);
228 keysize++;
229 } while (*keysize);
230
231 out:
232 crypto_free_blkcipher(tfm);
233 }
234
235 static int test_hash_jiffies_digest(struct hash_desc *desc,
236 struct scatterlist *sg, int blen,
237 char *out, int sec)
238 {
239 unsigned long start, end;
240 int bcount;
241 int ret;
242
243 for (start = jiffies, end = start + sec * HZ, bcount = 0;
244 time_before(jiffies, end); bcount++) {
245 ret = crypto_hash_digest(desc, sg, blen, out);
246 if (ret)
247 return ret;
248 }
249
250 printk("%6u opers/sec, %9lu bytes/sec\n",
251 bcount / sec, ((long)bcount * blen) / sec);
252
253 return 0;
254 }
255
256 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
257 int blen, int plen, char *out, int sec)
258 {
259 unsigned long start, end;
260 int bcount, pcount;
261 int ret;
262
263 if (plen == blen)
264 return test_hash_jiffies_digest(desc, sg, blen, out, sec);
265
266 for (start = jiffies, end = start + sec * HZ, bcount = 0;
267 time_before(jiffies, end); bcount++) {
268 ret = crypto_hash_init(desc);
269 if (ret)
270 return ret;
271 for (pcount = 0; pcount < blen; pcount += plen) {
272 ret = crypto_hash_update(desc, sg, plen);
273 if (ret)
274 return ret;
275 }
276 /* we assume there is enough space in 'out' for the result */
277 ret = crypto_hash_final(desc, out);
278 if (ret)
279 return ret;
280 }
281
282 printk("%6u opers/sec, %9lu bytes/sec\n",
283 bcount / sec, ((long)bcount * blen) / sec);
284
285 return 0;
286 }
287
288 static int test_hash_cycles_digest(struct hash_desc *desc,
289 struct scatterlist *sg, int blen, char *out)
290 {
291 unsigned long cycles = 0;
292 int i;
293 int ret;
294
295 local_bh_disable();
296 local_irq_disable();
297
298 /* Warm-up run. */
299 for (i = 0; i < 4; i++) {
300 ret = crypto_hash_digest(desc, sg, blen, out);
301 if (ret)
302 goto out;
303 }
304
305 /* The real thing. */
306 for (i = 0; i < 8; i++) {
307 cycles_t start, end;
308
309 start = get_cycles();
310
311 ret = crypto_hash_digest(desc, sg, blen, out);
312 if (ret)
313 goto out;
314
315 end = get_cycles();
316
317 cycles += end - start;
318 }
319
320 out:
321 local_irq_enable();
322 local_bh_enable();
323
324 if (ret)
325 return ret;
326
327 printk("%6lu cycles/operation, %4lu cycles/byte\n",
328 cycles / 8, cycles / (8 * blen));
329
330 return 0;
331 }
332
333 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
334 int blen, int plen, char *out)
335 {
336 unsigned long cycles = 0;
337 int i, pcount;
338 int ret;
339
340 if (plen == blen)
341 return test_hash_cycles_digest(desc, sg, blen, out);
342
343 local_bh_disable();
344 local_irq_disable();
345
346 /* Warm-up run. */
347 for (i = 0; i < 4; i++) {
348 ret = crypto_hash_init(desc);
349 if (ret)
350 goto out;
351 for (pcount = 0; pcount < blen; pcount += plen) {
352 ret = crypto_hash_update(desc, sg, plen);
353 if (ret)
354 goto out;
355 }
356 ret = crypto_hash_final(desc, out);
357 if (ret)
358 goto out;
359 }
360
361 /* The real thing. */
362 for (i = 0; i < 8; i++) {
363 cycles_t start, end;
364
365 start = get_cycles();
366
367 ret = crypto_hash_init(desc);
368 if (ret)
369 goto out;
370 for (pcount = 0; pcount < blen; pcount += plen) {
371 ret = crypto_hash_update(desc, sg, plen);
372 if (ret)
373 goto out;
374 }
375 ret = crypto_hash_final(desc, out);
376 if (ret)
377 goto out;
378
379 end = get_cycles();
380
381 cycles += end - start;
382 }
383
384 out:
385 local_irq_enable();
386 local_bh_enable();
387
388 if (ret)
389 return ret;
390
391 printk("%6lu cycles/operation, %4lu cycles/byte\n",
392 cycles / 8, cycles / (8 * blen));
393
394 return 0;
395 }
396
397 static void test_hash_speed(const char *algo, unsigned int sec,
398 struct hash_speed *speed)
399 {
400 struct scatterlist sg[TVMEMSIZE];
401 struct crypto_hash *tfm;
402 struct hash_desc desc;
403 static char output[1024];
404 int i;
405 int ret;
406
407 printk(KERN_INFO "\ntesting speed of %s\n", algo);
408
409 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
410
411 if (IS_ERR(tfm)) {
412 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
413 PTR_ERR(tfm));
414 return;
415 }
416
417 desc.tfm = tfm;
418 desc.flags = 0;
419
420 if (crypto_hash_digestsize(tfm) > sizeof(output)) {
421 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
422 crypto_hash_digestsize(tfm), sizeof(output));
423 goto out;
424 }
425
426 sg_init_table(sg, TVMEMSIZE);
427 for (i = 0; i < TVMEMSIZE; i++) {
428 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
429 memset(tvmem[i], 0xff, PAGE_SIZE);
430 }
431
432 for (i = 0; speed[i].blen != 0; i++) {
433 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
434 printk(KERN_ERR
435 "template (%u) too big for tvmem (%lu)\n",
436 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
437 goto out;
438 }
439
440 printk(KERN_INFO "test%3u "
441 "(%5u byte blocks,%5u bytes per update,%4u updates): ",
442 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
443
444 if (sec)
445 ret = test_hash_jiffies(&desc, sg, speed[i].blen,
446 speed[i].plen, output, sec);
447 else
448 ret = test_hash_cycles(&desc, sg, speed[i].blen,
449 speed[i].plen, output);
450
451 if (ret) {
452 printk(KERN_ERR "hashing failed ret=%d\n", ret);
453 break;
454 }
455 }
456
457 out:
458 crypto_free_hash(tfm);
459 }
460
461 static void test_available(void)
462 {
463 char **name = check;
464
465 while (*name) {
466 printk("alg %s ", *name);
467 printk(crypto_has_alg(*name, 0, 0) ?
468 "found\n" : "not found\n");
469 name++;
470 }
471 }
472
473 static inline int tcrypt_test(const char *alg)
474 {
475 int ret;
476
477 ret = alg_test(alg, alg, 0, 0);
478 /* non-fips algs return -EINVAL in fips mode */
479 if (fips_enabled && ret == -EINVAL)
480 ret = 0;
481 return ret;
482 }
483
484 static int do_test(int m)
485 {
486 int i;
487 int ret = 0;
488
489 switch (m) {
490 case 0:
491 for (i = 1; i < 200; i++)
492 ret += do_test(i);
493 break;
494
495 case 1:
496 ret += tcrypt_test("md5");
497 break;
498
499 case 2:
500 ret += tcrypt_test("sha1");
501 break;
502
503 case 3:
504 ret += tcrypt_test("ecb(des)");
505 ret += tcrypt_test("cbc(des)");
506 break;
507
508 case 4:
509 ret += tcrypt_test("ecb(des3_ede)");
510 ret += tcrypt_test("cbc(des3_ede)");
511 break;
512
513 case 5:
514 ret += tcrypt_test("md4");
515 break;
516
517 case 6:
518 ret += tcrypt_test("sha256");
519 break;
520
521 case 7:
522 ret += tcrypt_test("ecb(blowfish)");
523 ret += tcrypt_test("cbc(blowfish)");
524 break;
525
526 case 8:
527 ret += tcrypt_test("ecb(twofish)");
528 ret += tcrypt_test("cbc(twofish)");
529 break;
530
531 case 9:
532 ret += tcrypt_test("ecb(serpent)");
533 break;
534
535 case 10:
536 ret += tcrypt_test("ecb(aes)");
537 ret += tcrypt_test("cbc(aes)");
538 ret += tcrypt_test("lrw(aes)");
539 ret += tcrypt_test("xts(aes)");
540 ret += tcrypt_test("ctr(aes)");
541 ret += tcrypt_test("rfc3686(ctr(aes))");
542 break;
543
544 case 11:
545 ret += tcrypt_test("sha384");
546 break;
547
548 case 12:
549 ret += tcrypt_test("sha512");
550 break;
551
552 case 13:
553 ret += tcrypt_test("deflate");
554 break;
555
556 case 14:
557 ret += tcrypt_test("ecb(cast5)");
558 break;
559
560 case 15:
561 ret += tcrypt_test("ecb(cast6)");
562 break;
563
564 case 16:
565 ret += tcrypt_test("ecb(arc4)");
566 break;
567
568 case 17:
569 ret += tcrypt_test("michael_mic");
570 break;
571
572 case 18:
573 ret += tcrypt_test("crc32c");
574 break;
575
576 case 19:
577 ret += tcrypt_test("ecb(tea)");
578 break;
579
580 case 20:
581 ret += tcrypt_test("ecb(xtea)");
582 break;
583
584 case 21:
585 ret += tcrypt_test("ecb(khazad)");
586 break;
587
588 case 22:
589 ret += tcrypt_test("wp512");
590 break;
591
592 case 23:
593 ret += tcrypt_test("wp384");
594 break;
595
596 case 24:
597 ret += tcrypt_test("wp256");
598 break;
599
600 case 25:
601 ret += tcrypt_test("ecb(tnepres)");
602 break;
603
604 case 26:
605 ret += tcrypt_test("ecb(anubis)");
606 ret += tcrypt_test("cbc(anubis)");
607 break;
608
609 case 27:
610 ret += tcrypt_test("tgr192");
611 break;
612
613 case 28:
614
615 ret += tcrypt_test("tgr160");
616 break;
617
618 case 29:
619 ret += tcrypt_test("tgr128");
620 break;
621
622 case 30:
623 ret += tcrypt_test("ecb(xeta)");
624 break;
625
626 case 31:
627 ret += tcrypt_test("pcbc(fcrypt)");
628 break;
629
630 case 32:
631 ret += tcrypt_test("ecb(camellia)");
632 ret += tcrypt_test("cbc(camellia)");
633 break;
634 case 33:
635 ret += tcrypt_test("sha224");
636 break;
637
638 case 34:
639 ret += tcrypt_test("salsa20");
640 break;
641
642 case 35:
643 ret += tcrypt_test("gcm(aes)");
644 break;
645
646 case 36:
647 ret += tcrypt_test("lzo");
648 break;
649
650 case 37:
651 ret += tcrypt_test("ccm(aes)");
652 break;
653
654 case 38:
655 ret += tcrypt_test("cts(cbc(aes))");
656 break;
657
658 case 39:
659 ret += tcrypt_test("rmd128");
660 break;
661
662 case 40:
663 ret += tcrypt_test("rmd160");
664 break;
665
666 case 41:
667 ret += tcrypt_test("rmd256");
668 break;
669
670 case 42:
671 ret += tcrypt_test("rmd320");
672 break;
673
674 case 43:
675 ret += tcrypt_test("ecb(seed)");
676 break;
677
678 case 44:
679 ret += tcrypt_test("zlib");
680 break;
681
682 case 45:
683 ret += tcrypt_test("rfc4309(ccm(aes))");
684 break;
685
686 case 100:
687 ret += tcrypt_test("hmac(md5)");
688 break;
689
690 case 101:
691 ret += tcrypt_test("hmac(sha1)");
692 break;
693
694 case 102:
695 ret += tcrypt_test("hmac(sha256)");
696 break;
697
698 case 103:
699 ret += tcrypt_test("hmac(sha384)");
700 break;
701
702 case 104:
703 ret += tcrypt_test("hmac(sha512)");
704 break;
705
706 case 105:
707 ret += tcrypt_test("hmac(sha224)");
708 break;
709
710 case 106:
711 ret += tcrypt_test("xcbc(aes)");
712 break;
713
714 case 107:
715 ret += tcrypt_test("hmac(rmd128)");
716 break;
717
718 case 108:
719 ret += tcrypt_test("hmac(rmd160)");
720 break;
721
722 case 109:
723 ret += tcrypt_test("vmac(aes)");
724 break;
725
726 case 150:
727 ret += tcrypt_test("ansi_cprng");
728 break;
729
730 case 200:
731 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
732 speed_template_16_24_32);
733 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
734 speed_template_16_24_32);
735 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
736 speed_template_16_24_32);
737 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
738 speed_template_16_24_32);
739 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
740 speed_template_32_40_48);
741 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
742 speed_template_32_40_48);
743 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
744 speed_template_32_48_64);
745 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
746 speed_template_32_48_64);
747 break;
748
749 case 201:
750 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
751 des3_speed_template, DES3_SPEED_VECTORS,
752 speed_template_24);
753 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
754 des3_speed_template, DES3_SPEED_VECTORS,
755 speed_template_24);
756 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
757 des3_speed_template, DES3_SPEED_VECTORS,
758 speed_template_24);
759 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
760 des3_speed_template, DES3_SPEED_VECTORS,
761 speed_template_24);
762 break;
763
764 case 202:
765 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
766 speed_template_16_24_32);
767 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
768 speed_template_16_24_32);
769 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
770 speed_template_16_24_32);
771 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
772 speed_template_16_24_32);
773 break;
774
775 case 203:
776 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
777 speed_template_8_32);
778 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
779 speed_template_8_32);
780 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
781 speed_template_8_32);
782 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
783 speed_template_8_32);
784 break;
785
786 case 204:
787 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
788 speed_template_8);
789 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
790 speed_template_8);
791 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
792 speed_template_8);
793 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
794 speed_template_8);
795 break;
796
797 case 205:
798 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
799 speed_template_16_24_32);
800 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
801 speed_template_16_24_32);
802 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
803 speed_template_16_24_32);
804 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
805 speed_template_16_24_32);
806 break;
807
808 case 206:
809 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
810 speed_template_16_32);
811 break;
812
813 case 300:
814 /* fall through */
815
816 case 301:
817 test_hash_speed("md4", sec, generic_hash_speed_template);
818 if (mode > 300 && mode < 400) break;
819
820 case 302:
821 test_hash_speed("md5", sec, generic_hash_speed_template);
822 if (mode > 300 && mode < 400) break;
823
824 case 303:
825 test_hash_speed("sha1", sec, generic_hash_speed_template);
826 if (mode > 300 && mode < 400) break;
827
828 case 304:
829 test_hash_speed("sha256", sec, generic_hash_speed_template);
830 if (mode > 300 && mode < 400) break;
831
832 case 305:
833 test_hash_speed("sha384", sec, generic_hash_speed_template);
834 if (mode > 300 && mode < 400) break;
835
836 case 306:
837 test_hash_speed("sha512", sec, generic_hash_speed_template);
838 if (mode > 300 && mode < 400) break;
839
840 case 307:
841 test_hash_speed("wp256", sec, generic_hash_speed_template);
842 if (mode > 300 && mode < 400) break;
843
844 case 308:
845 test_hash_speed("wp384", sec, generic_hash_speed_template);
846 if (mode > 300 && mode < 400) break;
847
848 case 309:
849 test_hash_speed("wp512", sec, generic_hash_speed_template);
850 if (mode > 300 && mode < 400) break;
851
852 case 310:
853 test_hash_speed("tgr128", sec, generic_hash_speed_template);
854 if (mode > 300 && mode < 400) break;
855
856 case 311:
857 test_hash_speed("tgr160", sec, generic_hash_speed_template);
858 if (mode > 300 && mode < 400) break;
859
860 case 312:
861 test_hash_speed("tgr192", sec, generic_hash_speed_template);
862 if (mode > 300 && mode < 400) break;
863
864 case 313:
865 test_hash_speed("sha224", sec, generic_hash_speed_template);
866 if (mode > 300 && mode < 400) break;
867
868 case 314:
869 test_hash_speed("rmd128", sec, generic_hash_speed_template);
870 if (mode > 300 && mode < 400) break;
871
872 case 315:
873 test_hash_speed("rmd160", sec, generic_hash_speed_template);
874 if (mode > 300 && mode < 400) break;
875
876 case 316:
877 test_hash_speed("rmd256", sec, generic_hash_speed_template);
878 if (mode > 300 && mode < 400) break;
879
880 case 317:
881 test_hash_speed("rmd320", sec, generic_hash_speed_template);
882 if (mode > 300 && mode < 400) break;
883
884 case 399:
885 break;
886
887 case 1000:
888 test_available();
889 break;
890 }
891
892 return ret;
893 }
894
895 static int do_alg_test(const char *alg, u32 type, u32 mask)
896 {
897 return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
898 0 : -ENOENT;
899 }
900
901 static int __init tcrypt_mod_init(void)
902 {
903 int err = -ENOMEM;
904 int i;
905
906 for (i = 0; i < TVMEMSIZE; i++) {
907 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
908 if (!tvmem[i])
909 goto err_free_tv;
910 }
911
912 if (alg)
913 err = do_alg_test(alg, type, mask);
914 else
915 err = do_test(mode);
916
917 if (err) {
918 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
919 goto err_free_tv;
920 }
921
922 /* We intentionaly return -EAGAIN to prevent keeping the module,
923 * unless we're running in fips mode. It does all its work from
924 * init() and doesn't offer any runtime functionality, but in
925 * the fips case, checking for a successful load is helpful.
926 * => we don't need it in the memory, do we?
927 * -- mludvig
928 */
929 if (!fips_enabled)
930 err = -EAGAIN;
931
932 err_free_tv:
933 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
934 free_page((unsigned long)tvmem[i]);
935
936 return err;
937 }
938
939 /*
940 * If an init function is provided, an exit function must also be provided
941 * to allow module unload.
942 */
943 static void __exit tcrypt_mod_fini(void) { }
944
945 module_init(tcrypt_mod_init);
946 module_exit(tcrypt_mod_fini);
947
948 module_param(alg, charp, 0);
949 module_param(type, uint, 0);
950 module_param(mask, uint, 0);
951 module_param(mode, int, 0);
952 module_param(sec, uint, 0);
953 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
954 "(defaults to zero which uses CPU cycles instead)");
955
956 MODULE_LICENSE("GPL");
957 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
958 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
Linux ARM platform port for MOXA ART SoC