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