crypto: cryptomgr - Add test infrastructure
[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", 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         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
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
467 static inline int tcrypt_test(const char *alg)
468 {
469         return alg_test(alg, alg, 0, 0);
470 }
471
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
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  */
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>");