ea3b8a8db72104543fdfec22e9472c09702a89c0
[linux-2.6.git] / crypto / tcrypt.c
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", "zlib", NULL
57 };
58
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
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
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
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
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
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
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
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         static char output[1024];
400         int i;
401         int ret;
402
403         printk(KERN_INFO "\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(KERN_ERR "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(KERN_ERR "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(KERN_ERR
431                                "template (%u) too big for tvmem (%lu)\n",
432                                speed[i].blen, TVMEMSIZE * PAGE_SIZE);
433                         goto out;
434                 }
435
436                 printk(KERN_INFO "test%3u "
437                        "(%5u byte blocks,%5u bytes per update,%4u updates): ",
438                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
439
440                 if (sec)
441                         ret = test_hash_jiffies(&desc, sg, speed[i].blen,
442                                                 speed[i].plen, output, sec);
443                 else
444                         ret = test_hash_cycles(&desc, sg, speed[i].blen,
445                                                speed[i].plen, output);
446
447                 if (ret) {
448                         printk(KERN_ERR "hashing failed ret=%d\n", ret);
449                         break;
450                 }
451         }
452
453 out:
454         crypto_free_hash(tfm);
455 }
456
457 static void test_available(void)
458 {
459         char **name = check;
460
461         while (*name) {
462                 printk("alg %s ", *name);
463                 printk(crypto_has_alg(*name, 0, 0) ?
464                        "found\n" : "not found\n");
465                 name++;
466         }
467 }
468
469 static inline int tcrypt_test(const char *alg)
470 {
471         return alg_test(alg, alg, 0, 0);
472 }
473
474 static void do_test(int m)
475 {
476         int i;
477
478         switch (m) {
479         case 0:
480                 for (i = 1; i < 200; i++)
481                         do_test(i);
482                 break;
483
484         case 1:
485                 tcrypt_test("md5");
486                 break;
487
488         case 2:
489                 tcrypt_test("sha1");
490                 break;
491
492         case 3:
493                 tcrypt_test("ecb(des)");
494                 tcrypt_test("cbc(des)");
495                 break;
496
497         case 4:
498                 tcrypt_test("ecb(des3_ede)");
499                 tcrypt_test("cbc(des3_ede)");
500                 break;
501
502         case 5:
503                 tcrypt_test("md4");
504                 break;
505
506         case 6:
507                 tcrypt_test("sha256");
508                 break;
509
510         case 7:
511                 tcrypt_test("ecb(blowfish)");
512                 tcrypt_test("cbc(blowfish)");
513                 break;
514
515         case 8:
516                 tcrypt_test("ecb(twofish)");
517                 tcrypt_test("cbc(twofish)");
518                 break;
519
520         case 9:
521                 tcrypt_test("ecb(serpent)");
522                 break;
523
524         case 10:
525                 tcrypt_test("ecb(aes)");
526                 tcrypt_test("cbc(aes)");
527                 tcrypt_test("lrw(aes)");
528                 tcrypt_test("xts(aes)");
529                 tcrypt_test("rfc3686(ctr(aes))");
530                 break;
531
532         case 11:
533                 tcrypt_test("sha384");
534                 break;
535
536         case 12:
537                 tcrypt_test("sha512");
538                 break;
539
540         case 13:
541                 tcrypt_test("deflate");
542                 break;
543
544         case 14:
545                 tcrypt_test("ecb(cast5)");
546                 break;
547
548         case 15:
549                 tcrypt_test("ecb(cast6)");
550                 break;
551
552         case 16:
553                 tcrypt_test("ecb(arc4)");
554                 break;
555
556         case 17:
557                 tcrypt_test("michael_mic");
558                 break;
559
560         case 18:
561                 tcrypt_test("crc32c");
562                 break;
563
564         case 19:
565                 tcrypt_test("ecb(tea)");
566                 break;
567
568         case 20:
569                 tcrypt_test("ecb(xtea)");
570                 break;
571
572         case 21:
573                 tcrypt_test("ecb(khazad)");
574                 break;
575
576         case 22:
577                 tcrypt_test("wp512");
578                 break;
579
580         case 23:
581                 tcrypt_test("wp384");
582                 break;
583
584         case 24:
585                 tcrypt_test("wp256");
586                 break;
587
588         case 25:
589                 tcrypt_test("ecb(tnepres)");
590                 break;
591
592         case 26:
593                 tcrypt_test("ecb(anubis)");
594                 tcrypt_test("cbc(anubis)");
595                 break;
596
597         case 27:
598                 tcrypt_test("tgr192");
599                 break;
600
601         case 28:
602
603                 tcrypt_test("tgr160");
604                 break;
605
606         case 29:
607                 tcrypt_test("tgr128");
608                 break;
609
610         case 30:
611                 tcrypt_test("ecb(xeta)");
612                 break;
613
614         case 31:
615                 tcrypt_test("pcbc(fcrypt)");
616                 break;
617
618         case 32:
619                 tcrypt_test("ecb(camellia)");
620                 tcrypt_test("cbc(camellia)");
621                 break;
622         case 33:
623                 tcrypt_test("sha224");
624                 break;
625
626         case 34:
627                 tcrypt_test("salsa20");
628                 break;
629
630         case 35:
631                 tcrypt_test("gcm(aes)");
632                 break;
633
634         case 36:
635                 tcrypt_test("lzo");
636                 break;
637
638         case 37:
639                 tcrypt_test("ccm(aes)");
640                 break;
641
642         case 38:
643                 tcrypt_test("cts(cbc(aes))");
644                 break;
645
646         case 39:
647                 tcrypt_test("rmd128");
648                 break;
649
650         case 40:
651                 tcrypt_test("rmd160");
652                 break;
653
654         case 41:
655                 tcrypt_test("rmd256");
656                 break;
657
658         case 42:
659                 tcrypt_test("rmd320");
660                 break;
661
662         case 43:
663                 tcrypt_test("ecb(seed)");
664                 break;
665
666         case 44:
667                 tcrypt_test("zlib");
668                 break;
669
670         case 45:
671                 tcrypt_test("rfc4309(ccm(aes))");
672                 break;
673
674         case 100:
675                 tcrypt_test("hmac(md5)");
676                 break;
677
678         case 101:
679                 tcrypt_test("hmac(sha1)");
680                 break;
681
682         case 102:
683                 tcrypt_test("hmac(sha256)");
684                 break;
685
686         case 103:
687                 tcrypt_test("hmac(sha384)");
688                 break;
689
690         case 104:
691                 tcrypt_test("hmac(sha512)");
692                 break;
693
694         case 105:
695                 tcrypt_test("hmac(sha224)");
696                 break;
697
698         case 106:
699                 tcrypt_test("xcbc(aes)");
700                 break;
701
702         case 107:
703                 tcrypt_test("hmac(rmd128)");
704                 break;
705
706         case 108:
707                 tcrypt_test("hmac(rmd160)");
708                 break;
709
710         case 150:
711                 tcrypt_test("ansi_cprng");
712                 break;
713
714         case 200:
715                 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
716                                 speed_template_16_24_32);
717                 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
718                                 speed_template_16_24_32);
719                 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
720                                 speed_template_16_24_32);
721                 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
722                                 speed_template_16_24_32);
723                 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
724                                 speed_template_32_40_48);
725                 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
726                                 speed_template_32_40_48);
727                 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
728                                 speed_template_32_48_64);
729                 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
730                                 speed_template_32_48_64);
731                 break;
732
733         case 201:
734                 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
735                                 des3_speed_template, DES3_SPEED_VECTORS,
736                                 speed_template_24);
737                 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
738                                 des3_speed_template, DES3_SPEED_VECTORS,
739                                 speed_template_24);
740                 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
741                                 des3_speed_template, DES3_SPEED_VECTORS,
742                                 speed_template_24);
743                 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
744                                 des3_speed_template, DES3_SPEED_VECTORS,
745                                 speed_template_24);
746                 break;
747
748         case 202:
749                 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
750                                 speed_template_16_24_32);
751                 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
752                                 speed_template_16_24_32);
753                 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
754                                 speed_template_16_24_32);
755                 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
756                                 speed_template_16_24_32);
757                 break;
758
759         case 203:
760                 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
761                                   speed_template_8_32);
762                 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
763                                   speed_template_8_32);
764                 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
765                                   speed_template_8_32);
766                 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
767                                   speed_template_8_32);
768                 break;
769
770         case 204:
771                 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
772                                   speed_template_8);
773                 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
774                                   speed_template_8);
775                 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
776                                   speed_template_8);
777                 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
778                                   speed_template_8);
779                 break;
780
781         case 205:
782                 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
783                                 speed_template_16_24_32);
784                 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
785                                 speed_template_16_24_32);
786                 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
787                                 speed_template_16_24_32);
788                 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
789                                 speed_template_16_24_32);
790                 break;
791
792         case 206:
793                 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
794                                   speed_template_16_32);
795                 break;
796
797         case 300:
798                 /* fall through */
799
800         case 301:
801                 test_hash_speed("md4", sec, generic_hash_speed_template);
802                 if (mode > 300 && mode < 400) break;
803
804         case 302:
805                 test_hash_speed("md5", sec, generic_hash_speed_template);
806                 if (mode > 300 && mode < 400) break;
807
808         case 303:
809                 test_hash_speed("sha1", sec, generic_hash_speed_template);
810                 if (mode > 300 && mode < 400) break;
811
812         case 304:
813                 test_hash_speed("sha256", sec, generic_hash_speed_template);
814                 if (mode > 300 && mode < 400) break;
815
816         case 305:
817                 test_hash_speed("sha384", sec, generic_hash_speed_template);
818                 if (mode > 300 && mode < 400) break;
819
820         case 306:
821                 test_hash_speed("sha512", sec, generic_hash_speed_template);
822                 if (mode > 300 && mode < 400) break;
823
824         case 307:
825                 test_hash_speed("wp256", sec, generic_hash_speed_template);
826                 if (mode > 300 && mode < 400) break;
827
828         case 308:
829                 test_hash_speed("wp384", sec, generic_hash_speed_template);
830                 if (mode > 300 && mode < 400) break;
831
832         case 309:
833                 test_hash_speed("wp512", sec, generic_hash_speed_template);
834                 if (mode > 300 && mode < 400) break;
835
836         case 310:
837                 test_hash_speed("tgr128", sec, generic_hash_speed_template);
838                 if (mode > 300 && mode < 400) break;
839
840         case 311:
841                 test_hash_speed("tgr160", sec, generic_hash_speed_template);
842                 if (mode > 300 && mode < 400) break;
843
844         case 312:
845                 test_hash_speed("tgr192", sec, generic_hash_speed_template);
846                 if (mode > 300 && mode < 400) break;
847
848         case 313:
849                 test_hash_speed("sha224", sec, generic_hash_speed_template);
850                 if (mode > 300 && mode < 400) break;
851
852         case 314:
853                 test_hash_speed("rmd128", sec, generic_hash_speed_template);
854                 if (mode > 300 && mode < 400) break;
855
856         case 315:
857                 test_hash_speed("rmd160", sec, generic_hash_speed_template);
858                 if (mode > 300 && mode < 400) break;
859
860         case 316:
861                 test_hash_speed("rmd256", sec, generic_hash_speed_template);
862                 if (mode > 300 && mode < 400) break;
863
864         case 317:
865                 test_hash_speed("rmd320", sec, generic_hash_speed_template);
866                 if (mode > 300 && mode < 400) break;
867
868         case 399:
869                 break;
870
871         case 1000:
872                 test_available();
873                 break;
874         }
875 }
876
877 static int __init tcrypt_mod_init(void)
878 {
879         int err = -ENOMEM;
880         int i;
881
882         for (i = 0; i < TVMEMSIZE; i++) {
883                 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
884                 if (!tvmem[i])
885                         goto err_free_tv;
886         }
887
888         do_test(mode);
889
890         /* We intentionaly return -EAGAIN to prevent keeping
891          * the module. It does all its work from init()
892          * and doesn't offer any runtime functionality 
893          * => we don't need it in the memory, do we?
894          *                                        -- mludvig
895          */
896         err = -EAGAIN;
897
898 err_free_tv:
899         for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
900                 free_page((unsigned long)tvmem[i]);
901
902         return err;
903 }
904
905 /*
906  * If an init function is provided, an exit function must also be provided
907  * to allow module unload.
908  */
909 static void __exit tcrypt_mod_fini(void) { }
910
911 module_init(tcrypt_mod_init);
912 module_exit(tcrypt_mod_fini);
913
914 module_param(mode, int, 0);
915 module_param(sec, uint, 0);
916 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
917                       "(defaults to zero which uses CPU cycles instead)");
918
919 MODULE_LICENSE("GPL");
920 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
921 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");