Merge tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi
[firefly-linux-kernel-4.4.55.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  * Updated RFC4106 AES-GCM testing.
12  *    Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
13  *             Adrian Hoban <adrian.hoban@intel.com>
14  *             Gabriele Paoloni <gabriele.paoloni@intel.com>
15  *             Tadeusz Struk (tadeusz.struk@intel.com)
16  *             Copyright (c) 2010, Intel Corporation.
17  *
18  * This program is free software; you can redistribute it and/or modify it
19  * under the terms of the GNU General Public License as published by the Free
20  * Software Foundation; either version 2 of the License, or (at your option)
21  * any later version.
22  *
23  */
24
25 #include <crypto/aead.h>
26 #include <crypto/hash.h>
27 #include <linux/err.h>
28 #include <linux/fips.h>
29 #include <linux/init.h>
30 #include <linux/gfp.h>
31 #include <linux/module.h>
32 #include <linux/scatterlist.h>
33 #include <linux/string.h>
34 #include <linux/moduleparam.h>
35 #include <linux/jiffies.h>
36 #include <linux/timex.h>
37 #include <linux/interrupt.h>
38 #include "tcrypt.h"
39
40 /*
41  * Need slab memory for testing (size in number of pages).
42  */
43 #define TVMEMSIZE       4
44
45 /*
46 * Used by test_cipher_speed()
47 */
48 #define ENCRYPT 1
49 #define DECRYPT 0
50
51 /*
52  * return a string with the driver name
53  */
54 #define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm))
55
56 /*
57  * Used by test_cipher_speed()
58  */
59 static unsigned int sec;
60
61 static char *alg = NULL;
62 static u32 type;
63 static u32 mask;
64 static int mode;
65 static char *tvmem[TVMEMSIZE];
66
67 static char *check[] = {
68         "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
69         "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
70         "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
71         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
72         "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
73         "lzo", "cts", "zlib", NULL
74 };
75
76 struct tcrypt_result {
77         struct completion completion;
78         int err;
79 };
80
81 static void tcrypt_complete(struct crypto_async_request *req, int err)
82 {
83         struct tcrypt_result *res = req->data;
84
85         if (err == -EINPROGRESS)
86                 return;
87
88         res->err = err;
89         complete(&res->completion);
90 }
91
92 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
93                                struct scatterlist *sg, int blen, int secs)
94 {
95         unsigned long start, end;
96         int bcount;
97         int ret;
98
99         for (start = jiffies, end = start + secs * HZ, bcount = 0;
100              time_before(jiffies, end); bcount++) {
101                 if (enc)
102                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
103                 else
104                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
105
106                 if (ret)
107                         return ret;
108         }
109
110         printk("%d operations in %d seconds (%ld bytes)\n",
111                bcount, secs, (long)bcount * blen);
112         return 0;
113 }
114
115 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
116                               struct scatterlist *sg, int blen)
117 {
118         unsigned long cycles = 0;
119         int ret = 0;
120         int i;
121
122         local_irq_disable();
123
124         /* Warm-up run. */
125         for (i = 0; i < 4; i++) {
126                 if (enc)
127                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
128                 else
129                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
130
131                 if (ret)
132                         goto out;
133         }
134
135         /* The real thing. */
136         for (i = 0; i < 8; i++) {
137                 cycles_t start, end;
138
139                 start = get_cycles();
140                 if (enc)
141                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
142                 else
143                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
144                 end = get_cycles();
145
146                 if (ret)
147                         goto out;
148
149                 cycles += end - start;
150         }
151
152 out:
153         local_irq_enable();
154
155         if (ret == 0)
156                 printk("1 operation in %lu cycles (%d bytes)\n",
157                        (cycles + 4) / 8, blen);
158
159         return ret;
160 }
161
162 static inline int do_one_aead_op(struct aead_request *req, int ret)
163 {
164         if (ret == -EINPROGRESS || ret == -EBUSY) {
165                 struct tcrypt_result *tr = req->base.data;
166
167                 ret = wait_for_completion_interruptible(&tr->completion);
168                 if (!ret)
169                         ret = tr->err;
170                 reinit_completion(&tr->completion);
171         }
172
173         return ret;
174 }
175
176 static int test_aead_jiffies(struct aead_request *req, int enc,
177                                 int blen, int secs)
178 {
179         unsigned long start, end;
180         int bcount;
181         int ret;
182
183         for (start = jiffies, end = start + secs * HZ, bcount = 0;
184              time_before(jiffies, end); bcount++) {
185                 if (enc)
186                         ret = do_one_aead_op(req, crypto_aead_encrypt(req));
187                 else
188                         ret = do_one_aead_op(req, crypto_aead_decrypt(req));
189
190                 if (ret)
191                         return ret;
192         }
193
194         printk("%d operations in %d seconds (%ld bytes)\n",
195                bcount, secs, (long)bcount * blen);
196         return 0;
197 }
198
199 static int test_aead_cycles(struct aead_request *req, int enc, int blen)
200 {
201         unsigned long cycles = 0;
202         int ret = 0;
203         int i;
204
205         local_irq_disable();
206
207         /* Warm-up run. */
208         for (i = 0; i < 4; i++) {
209                 if (enc)
210                         ret = do_one_aead_op(req, crypto_aead_encrypt(req));
211                 else
212                         ret = do_one_aead_op(req, crypto_aead_decrypt(req));
213
214                 if (ret)
215                         goto out;
216         }
217
218         /* The real thing. */
219         for (i = 0; i < 8; i++) {
220                 cycles_t start, end;
221
222                 start = get_cycles();
223                 if (enc)
224                         ret = do_one_aead_op(req, crypto_aead_encrypt(req));
225                 else
226                         ret = do_one_aead_op(req, crypto_aead_decrypt(req));
227                 end = get_cycles();
228
229                 if (ret)
230                         goto out;
231
232                 cycles += end - start;
233         }
234
235 out:
236         local_irq_enable();
237
238         if (ret == 0)
239                 printk("1 operation in %lu cycles (%d bytes)\n",
240                        (cycles + 4) / 8, blen);
241
242         return ret;
243 }
244
245 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
246 static u32 aead_sizes[] = { 16, 64, 256, 512, 1024, 2048, 4096, 8192, 0 };
247
248 #define XBUFSIZE 8
249 #define MAX_IVLEN 32
250
251 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
252 {
253         int i;
254
255         for (i = 0; i < XBUFSIZE; i++) {
256                 buf[i] = (void *)__get_free_page(GFP_KERNEL);
257                 if (!buf[i])
258                         goto err_free_buf;
259         }
260
261         return 0;
262
263 err_free_buf:
264         while (i-- > 0)
265                 free_page((unsigned long)buf[i]);
266
267         return -ENOMEM;
268 }
269
270 static void testmgr_free_buf(char *buf[XBUFSIZE])
271 {
272         int i;
273
274         for (i = 0; i < XBUFSIZE; i++)
275                 free_page((unsigned long)buf[i]);
276 }
277
278 static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE],
279                         unsigned int buflen)
280 {
281         int np = (buflen + PAGE_SIZE - 1)/PAGE_SIZE;
282         int k, rem;
283
284         if (np > XBUFSIZE) {
285                 rem = PAGE_SIZE;
286                 np = XBUFSIZE;
287         } else {
288                 rem = buflen % PAGE_SIZE;
289         }
290
291         sg_init_table(sg, np + 1);
292         np--;
293         for (k = 0; k < np; k++)
294                 sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE);
295
296         sg_set_buf(&sg[k + 1], xbuf[k], rem);
297 }
298
299 static void test_aead_speed(const char *algo, int enc, unsigned int secs,
300                             struct aead_speed_template *template,
301                             unsigned int tcount, u8 authsize,
302                             unsigned int aad_size, u8 *keysize)
303 {
304         unsigned int i, j;
305         struct crypto_aead *tfm;
306         int ret = -ENOMEM;
307         const char *key;
308         struct aead_request *req;
309         struct scatterlist *sg;
310         struct scatterlist *sgout;
311         const char *e;
312         void *assoc;
313         char *iv;
314         char *xbuf[XBUFSIZE];
315         char *xoutbuf[XBUFSIZE];
316         char *axbuf[XBUFSIZE];
317         unsigned int *b_size;
318         unsigned int iv_len;
319         struct tcrypt_result result;
320
321         iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
322         if (!iv)
323                 return;
324
325         if (aad_size >= PAGE_SIZE) {
326                 pr_err("associate data length (%u) too big\n", aad_size);
327                 goto out_noxbuf;
328         }
329
330         if (enc == ENCRYPT)
331                 e = "encryption";
332         else
333                 e = "decryption";
334
335         if (testmgr_alloc_buf(xbuf))
336                 goto out_noxbuf;
337         if (testmgr_alloc_buf(axbuf))
338                 goto out_noaxbuf;
339         if (testmgr_alloc_buf(xoutbuf))
340                 goto out_nooutbuf;
341
342         sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL);
343         if (!sg)
344                 goto out_nosg;
345         sgout = &sg[9];
346
347         tfm = crypto_alloc_aead(algo, 0, 0);
348
349         if (IS_ERR(tfm)) {
350                 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo,
351                        PTR_ERR(tfm));
352                 goto out_notfm;
353         }
354
355         init_completion(&result.completion);
356         printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
357                         get_driver_name(crypto_aead, tfm), e);
358
359         req = aead_request_alloc(tfm, GFP_KERNEL);
360         if (!req) {
361                 pr_err("alg: aead: Failed to allocate request for %s\n",
362                        algo);
363                 goto out_noreq;
364         }
365
366         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
367                                   tcrypt_complete, &result);
368
369         i = 0;
370         do {
371                 b_size = aead_sizes;
372                 do {
373                         assoc = axbuf[0];
374                         memset(assoc, 0xff, aad_size);
375
376                         if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
377                                 pr_err("template (%u) too big for tvmem (%lu)\n",
378                                        *keysize + *b_size,
379                                         TVMEMSIZE * PAGE_SIZE);
380                                 goto out;
381                         }
382
383                         key = tvmem[0];
384                         for (j = 0; j < tcount; j++) {
385                                 if (template[j].klen == *keysize) {
386                                         key = template[j].key;
387                                         break;
388                                 }
389                         }
390                         ret = crypto_aead_setkey(tfm, key, *keysize);
391                         ret = crypto_aead_setauthsize(tfm, authsize);
392
393                         iv_len = crypto_aead_ivsize(tfm);
394                         if (iv_len)
395                                 memset(iv, 0xff, iv_len);
396
397                         crypto_aead_clear_flags(tfm, ~0);
398                         printk(KERN_INFO "test %u (%d bit key, %d byte blocks): ",
399                                         i, *keysize * 8, *b_size);
400
401
402                         memset(tvmem[0], 0xff, PAGE_SIZE);
403
404                         if (ret) {
405                                 pr_err("setkey() failed flags=%x\n",
406                                                 crypto_aead_get_flags(tfm));
407                                 goto out;
408                         }
409
410                         sg_init_aead(sg, xbuf,
411                                     *b_size + (enc ? authsize : 0));
412
413                         sg_init_aead(sgout, xoutbuf,
414                                     *b_size + (enc ? authsize : 0));
415
416                         sg_set_buf(&sg[0], assoc, aad_size);
417                         sg_set_buf(&sgout[0], assoc, aad_size);
418
419                         aead_request_set_crypt(req, sg, sgout, *b_size, iv);
420                         aead_request_set_ad(req, aad_size);
421
422                         if (secs)
423                                 ret = test_aead_jiffies(req, enc, *b_size,
424                                                         secs);
425                         else
426                                 ret = test_aead_cycles(req, enc, *b_size);
427
428                         if (ret) {
429                                 pr_err("%s() failed return code=%d\n", e, ret);
430                                 break;
431                         }
432                         b_size++;
433                         i++;
434                 } while (*b_size);
435                 keysize++;
436         } while (*keysize);
437
438 out:
439         aead_request_free(req);
440 out_noreq:
441         crypto_free_aead(tfm);
442 out_notfm:
443         kfree(sg);
444 out_nosg:
445         testmgr_free_buf(xoutbuf);
446 out_nooutbuf:
447         testmgr_free_buf(axbuf);
448 out_noaxbuf:
449         testmgr_free_buf(xbuf);
450 out_noxbuf:
451         kfree(iv);
452         return;
453 }
454
455 static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
456                               struct cipher_speed_template *template,
457                               unsigned int tcount, u8 *keysize)
458 {
459         unsigned int ret, i, j, iv_len;
460         const char *key;
461         char iv[128];
462         struct crypto_blkcipher *tfm;
463         struct blkcipher_desc desc;
464         const char *e;
465         u32 *b_size;
466
467         if (enc == ENCRYPT)
468                 e = "encryption";
469         else
470                 e = "decryption";
471
472         tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
473
474         if (IS_ERR(tfm)) {
475                 printk("failed to load transform for %s: %ld\n", algo,
476                        PTR_ERR(tfm));
477                 return;
478         }
479         desc.tfm = tfm;
480         desc.flags = 0;
481
482         printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
483                         get_driver_name(crypto_blkcipher, tfm), e);
484
485         i = 0;
486         do {
487
488                 b_size = block_sizes;
489                 do {
490                         struct scatterlist sg[TVMEMSIZE];
491
492                         if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
493                                 printk("template (%u) too big for "
494                                        "tvmem (%lu)\n", *keysize + *b_size,
495                                        TVMEMSIZE * PAGE_SIZE);
496                                 goto out;
497                         }
498
499                         printk("test %u (%d bit key, %d byte blocks): ", i,
500                                         *keysize * 8, *b_size);
501
502                         memset(tvmem[0], 0xff, PAGE_SIZE);
503
504                         /* set key, plain text and IV */
505                         key = tvmem[0];
506                         for (j = 0; j < tcount; j++) {
507                                 if (template[j].klen == *keysize) {
508                                         key = template[j].key;
509                                         break;
510                                 }
511                         }
512
513                         ret = crypto_blkcipher_setkey(tfm, key, *keysize);
514                         if (ret) {
515                                 printk("setkey() failed flags=%x\n",
516                                                 crypto_blkcipher_get_flags(tfm));
517                                 goto out;
518                         }
519
520                         sg_init_table(sg, TVMEMSIZE);
521                         sg_set_buf(sg, tvmem[0] + *keysize,
522                                    PAGE_SIZE - *keysize);
523                         for (j = 1; j < TVMEMSIZE; j++) {
524                                 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
525                                 memset (tvmem[j], 0xff, PAGE_SIZE);
526                         }
527
528                         iv_len = crypto_blkcipher_ivsize(tfm);
529                         if (iv_len) {
530                                 memset(&iv, 0xff, iv_len);
531                                 crypto_blkcipher_set_iv(tfm, iv, iv_len);
532                         }
533
534                         if (secs)
535                                 ret = test_cipher_jiffies(&desc, enc, sg,
536                                                           *b_size, secs);
537                         else
538                                 ret = test_cipher_cycles(&desc, enc, sg,
539                                                          *b_size);
540
541                         if (ret) {
542                                 printk("%s() failed flags=%x\n", e, desc.flags);
543                                 break;
544                         }
545                         b_size++;
546                         i++;
547                 } while (*b_size);
548                 keysize++;
549         } while (*keysize);
550
551 out:
552         crypto_free_blkcipher(tfm);
553 }
554
555 static int test_hash_jiffies_digest(struct hash_desc *desc,
556                                     struct scatterlist *sg, int blen,
557                                     char *out, int secs)
558 {
559         unsigned long start, end;
560         int bcount;
561         int ret;
562
563         for (start = jiffies, end = start + secs * HZ, bcount = 0;
564              time_before(jiffies, end); bcount++) {
565                 ret = crypto_hash_digest(desc, sg, blen, out);
566                 if (ret)
567                         return ret;
568         }
569
570         printk("%6u opers/sec, %9lu bytes/sec\n",
571                bcount / secs, ((long)bcount * blen) / secs);
572
573         return 0;
574 }
575
576 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
577                              int blen, int plen, char *out, int secs)
578 {
579         unsigned long start, end;
580         int bcount, pcount;
581         int ret;
582
583         if (plen == blen)
584                 return test_hash_jiffies_digest(desc, sg, blen, out, secs);
585
586         for (start = jiffies, end = start + secs * HZ, bcount = 0;
587              time_before(jiffies, end); bcount++) {
588                 ret = crypto_hash_init(desc);
589                 if (ret)
590                         return ret;
591                 for (pcount = 0; pcount < blen; pcount += plen) {
592                         ret = crypto_hash_update(desc, sg, plen);
593                         if (ret)
594                                 return ret;
595                 }
596                 /* we assume there is enough space in 'out' for the result */
597                 ret = crypto_hash_final(desc, out);
598                 if (ret)
599                         return ret;
600         }
601
602         printk("%6u opers/sec, %9lu bytes/sec\n",
603                bcount / secs, ((long)bcount * blen) / secs);
604
605         return 0;
606 }
607
608 static int test_hash_cycles_digest(struct hash_desc *desc,
609                                    struct scatterlist *sg, int blen, char *out)
610 {
611         unsigned long cycles = 0;
612         int i;
613         int ret;
614
615         local_irq_disable();
616
617         /* Warm-up run. */
618         for (i = 0; i < 4; i++) {
619                 ret = crypto_hash_digest(desc, sg, blen, out);
620                 if (ret)
621                         goto out;
622         }
623
624         /* The real thing. */
625         for (i = 0; i < 8; i++) {
626                 cycles_t start, end;
627
628                 start = get_cycles();
629
630                 ret = crypto_hash_digest(desc, sg, blen, out);
631                 if (ret)
632                         goto out;
633
634                 end = get_cycles();
635
636                 cycles += end - start;
637         }
638
639 out:
640         local_irq_enable();
641
642         if (ret)
643                 return ret;
644
645         printk("%6lu cycles/operation, %4lu cycles/byte\n",
646                cycles / 8, cycles / (8 * blen));
647
648         return 0;
649 }
650
651 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
652                             int blen, int plen, char *out)
653 {
654         unsigned long cycles = 0;
655         int i, pcount;
656         int ret;
657
658         if (plen == blen)
659                 return test_hash_cycles_digest(desc, sg, blen, out);
660
661         local_irq_disable();
662
663         /* Warm-up run. */
664         for (i = 0; i < 4; i++) {
665                 ret = crypto_hash_init(desc);
666                 if (ret)
667                         goto out;
668                 for (pcount = 0; pcount < blen; pcount += plen) {
669                         ret = crypto_hash_update(desc, sg, plen);
670                         if (ret)
671                                 goto out;
672                 }
673                 ret = crypto_hash_final(desc, out);
674                 if (ret)
675                         goto out;
676         }
677
678         /* The real thing. */
679         for (i = 0; i < 8; i++) {
680                 cycles_t start, end;
681
682                 start = get_cycles();
683
684                 ret = crypto_hash_init(desc);
685                 if (ret)
686                         goto out;
687                 for (pcount = 0; pcount < blen; pcount += plen) {
688                         ret = crypto_hash_update(desc, sg, plen);
689                         if (ret)
690                                 goto out;
691                 }
692                 ret = crypto_hash_final(desc, out);
693                 if (ret)
694                         goto out;
695
696                 end = get_cycles();
697
698                 cycles += end - start;
699         }
700
701 out:
702         local_irq_enable();
703
704         if (ret)
705                 return ret;
706
707         printk("%6lu cycles/operation, %4lu cycles/byte\n",
708                cycles / 8, cycles / (8 * blen));
709
710         return 0;
711 }
712
713 static void test_hash_sg_init(struct scatterlist *sg)
714 {
715         int i;
716
717         sg_init_table(sg, TVMEMSIZE);
718         for (i = 0; i < TVMEMSIZE; i++) {
719                 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
720                 memset(tvmem[i], 0xff, PAGE_SIZE);
721         }
722 }
723
724 static void test_hash_speed(const char *algo, unsigned int secs,
725                             struct hash_speed *speed)
726 {
727         struct scatterlist sg[TVMEMSIZE];
728         struct crypto_hash *tfm;
729         struct hash_desc desc;
730         static char output[1024];
731         int i;
732         int ret;
733
734         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
735
736         if (IS_ERR(tfm)) {
737                 printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
738                        PTR_ERR(tfm));
739                 return;
740         }
741
742         printk(KERN_INFO "\ntesting speed of %s (%s)\n", algo,
743                         get_driver_name(crypto_hash, tfm));
744
745         desc.tfm = tfm;
746         desc.flags = 0;
747
748         if (crypto_hash_digestsize(tfm) > sizeof(output)) {
749                 printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
750                        crypto_hash_digestsize(tfm), sizeof(output));
751                 goto out;
752         }
753
754         test_hash_sg_init(sg);
755         for (i = 0; speed[i].blen != 0; i++) {
756                 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
757                         printk(KERN_ERR
758                                "template (%u) too big for tvmem (%lu)\n",
759                                speed[i].blen, TVMEMSIZE * PAGE_SIZE);
760                         goto out;
761                 }
762
763                 if (speed[i].klen)
764                         crypto_hash_setkey(tfm, tvmem[0], speed[i].klen);
765
766                 printk(KERN_INFO "test%3u "
767                        "(%5u byte blocks,%5u bytes per update,%4u updates): ",
768                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
769
770                 if (secs)
771                         ret = test_hash_jiffies(&desc, sg, speed[i].blen,
772                                                 speed[i].plen, output, secs);
773                 else
774                         ret = test_hash_cycles(&desc, sg, speed[i].blen,
775                                                speed[i].plen, output);
776
777                 if (ret) {
778                         printk(KERN_ERR "hashing failed ret=%d\n", ret);
779                         break;
780                 }
781         }
782
783 out:
784         crypto_free_hash(tfm);
785 }
786
787 static inline int do_one_ahash_op(struct ahash_request *req, int ret)
788 {
789         if (ret == -EINPROGRESS || ret == -EBUSY) {
790                 struct tcrypt_result *tr = req->base.data;
791
792                 wait_for_completion(&tr->completion);
793                 reinit_completion(&tr->completion);
794                 ret = tr->err;
795         }
796         return ret;
797 }
798
799 static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
800                                      char *out, int secs)
801 {
802         unsigned long start, end;
803         int bcount;
804         int ret;
805
806         for (start = jiffies, end = start + secs * HZ, bcount = 0;
807              time_before(jiffies, end); bcount++) {
808                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
809                 if (ret)
810                         return ret;
811         }
812
813         printk("%6u opers/sec, %9lu bytes/sec\n",
814                bcount / secs, ((long)bcount * blen) / secs);
815
816         return 0;
817 }
818
819 static int test_ahash_jiffies(struct ahash_request *req, int blen,
820                               int plen, char *out, int secs)
821 {
822         unsigned long start, end;
823         int bcount, pcount;
824         int ret;
825
826         if (plen == blen)
827                 return test_ahash_jiffies_digest(req, blen, out, secs);
828
829         for (start = jiffies, end = start + secs * HZ, bcount = 0;
830              time_before(jiffies, end); bcount++) {
831                 ret = do_one_ahash_op(req, crypto_ahash_init(req));
832                 if (ret)
833                         return ret;
834                 for (pcount = 0; pcount < blen; pcount += plen) {
835                         ret = do_one_ahash_op(req, crypto_ahash_update(req));
836                         if (ret)
837                                 return ret;
838                 }
839                 /* we assume there is enough space in 'out' for the result */
840                 ret = do_one_ahash_op(req, crypto_ahash_final(req));
841                 if (ret)
842                         return ret;
843         }
844
845         pr_cont("%6u opers/sec, %9lu bytes/sec\n",
846                 bcount / secs, ((long)bcount * blen) / secs);
847
848         return 0;
849 }
850
851 static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
852                                     char *out)
853 {
854         unsigned long cycles = 0;
855         int ret, i;
856
857         /* Warm-up run. */
858         for (i = 0; i < 4; i++) {
859                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
860                 if (ret)
861                         goto out;
862         }
863
864         /* The real thing. */
865         for (i = 0; i < 8; i++) {
866                 cycles_t start, end;
867
868                 start = get_cycles();
869
870                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
871                 if (ret)
872                         goto out;
873
874                 end = get_cycles();
875
876                 cycles += end - start;
877         }
878
879 out:
880         if (ret)
881                 return ret;
882
883         pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
884                 cycles / 8, cycles / (8 * blen));
885
886         return 0;
887 }
888
889 static int test_ahash_cycles(struct ahash_request *req, int blen,
890                              int plen, char *out)
891 {
892         unsigned long cycles = 0;
893         int i, pcount, ret;
894
895         if (plen == blen)
896                 return test_ahash_cycles_digest(req, blen, out);
897
898         /* Warm-up run. */
899         for (i = 0; i < 4; i++) {
900                 ret = do_one_ahash_op(req, crypto_ahash_init(req));
901                 if (ret)
902                         goto out;
903                 for (pcount = 0; pcount < blen; pcount += plen) {
904                         ret = do_one_ahash_op(req, crypto_ahash_update(req));
905                         if (ret)
906                                 goto out;
907                 }
908                 ret = do_one_ahash_op(req, crypto_ahash_final(req));
909                 if (ret)
910                         goto out;
911         }
912
913         /* The real thing. */
914         for (i = 0; i < 8; i++) {
915                 cycles_t start, end;
916
917                 start = get_cycles();
918
919                 ret = do_one_ahash_op(req, crypto_ahash_init(req));
920                 if (ret)
921                         goto out;
922                 for (pcount = 0; pcount < blen; pcount += plen) {
923                         ret = do_one_ahash_op(req, crypto_ahash_update(req));
924                         if (ret)
925                                 goto out;
926                 }
927                 ret = do_one_ahash_op(req, crypto_ahash_final(req));
928                 if (ret)
929                         goto out;
930
931                 end = get_cycles();
932
933                 cycles += end - start;
934         }
935
936 out:
937         if (ret)
938                 return ret;
939
940         pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
941                 cycles / 8, cycles / (8 * blen));
942
943         return 0;
944 }
945
946 static void test_ahash_speed(const char *algo, unsigned int secs,
947                              struct hash_speed *speed)
948 {
949         struct scatterlist sg[TVMEMSIZE];
950         struct tcrypt_result tresult;
951         struct ahash_request *req;
952         struct crypto_ahash *tfm;
953         static char output[1024];
954         int i, ret;
955
956         tfm = crypto_alloc_ahash(algo, 0, 0);
957         if (IS_ERR(tfm)) {
958                 pr_err("failed to load transform for %s: %ld\n",
959                        algo, PTR_ERR(tfm));
960                 return;
961         }
962
963         printk(KERN_INFO "\ntesting speed of async %s (%s)\n", algo,
964                         get_driver_name(crypto_ahash, tfm));
965
966         if (crypto_ahash_digestsize(tfm) > sizeof(output)) {
967                 pr_err("digestsize(%u) > outputbuffer(%zu)\n",
968                        crypto_ahash_digestsize(tfm), sizeof(output));
969                 goto out;
970         }
971
972         test_hash_sg_init(sg);
973         req = ahash_request_alloc(tfm, GFP_KERNEL);
974         if (!req) {
975                 pr_err("ahash request allocation failure\n");
976                 goto out;
977         }
978
979         init_completion(&tresult.completion);
980         ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
981                                    tcrypt_complete, &tresult);
982
983         for (i = 0; speed[i].blen != 0; i++) {
984                 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
985                         pr_err("template (%u) too big for tvmem (%lu)\n",
986                                speed[i].blen, TVMEMSIZE * PAGE_SIZE);
987                         break;
988                 }
989
990                 pr_info("test%3u "
991                         "(%5u byte blocks,%5u bytes per update,%4u updates): ",
992                         i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
993
994                 ahash_request_set_crypt(req, sg, output, speed[i].plen);
995
996                 if (secs)
997                         ret = test_ahash_jiffies(req, speed[i].blen,
998                                                  speed[i].plen, output, secs);
999                 else
1000                         ret = test_ahash_cycles(req, speed[i].blen,
1001                                                 speed[i].plen, output);
1002
1003                 if (ret) {
1004                         pr_err("hashing failed ret=%d\n", ret);
1005                         break;
1006                 }
1007         }
1008
1009         ahash_request_free(req);
1010
1011 out:
1012         crypto_free_ahash(tfm);
1013 }
1014
1015 static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)
1016 {
1017         if (ret == -EINPROGRESS || ret == -EBUSY) {
1018                 struct tcrypt_result *tr = req->base.data;
1019
1020                 wait_for_completion(&tr->completion);
1021                 reinit_completion(&tr->completion);
1022                 ret = tr->err;
1023         }
1024
1025         return ret;
1026 }
1027
1028 static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
1029                                 int blen, int secs)
1030 {
1031         unsigned long start, end;
1032         int bcount;
1033         int ret;
1034
1035         for (start = jiffies, end = start + secs * HZ, bcount = 0;
1036              time_before(jiffies, end); bcount++) {
1037                 if (enc)
1038                         ret = do_one_acipher_op(req,
1039                                                 crypto_ablkcipher_encrypt(req));
1040                 else
1041                         ret = do_one_acipher_op(req,
1042                                                 crypto_ablkcipher_decrypt(req));
1043
1044                 if (ret)
1045                         return ret;
1046         }
1047
1048         pr_cont("%d operations in %d seconds (%ld bytes)\n",
1049                 bcount, secs, (long)bcount * blen);
1050         return 0;
1051 }
1052
1053 static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
1054                                int blen)
1055 {
1056         unsigned long cycles = 0;
1057         int ret = 0;
1058         int i;
1059
1060         /* Warm-up run. */
1061         for (i = 0; i < 4; i++) {
1062                 if (enc)
1063                         ret = do_one_acipher_op(req,
1064                                                 crypto_ablkcipher_encrypt(req));
1065                 else
1066                         ret = do_one_acipher_op(req,
1067                                                 crypto_ablkcipher_decrypt(req));
1068
1069                 if (ret)
1070                         goto out;
1071         }
1072
1073         /* The real thing. */
1074         for (i = 0; i < 8; i++) {
1075                 cycles_t start, end;
1076
1077                 start = get_cycles();
1078                 if (enc)
1079                         ret = do_one_acipher_op(req,
1080                                                 crypto_ablkcipher_encrypt(req));
1081                 else
1082                         ret = do_one_acipher_op(req,
1083                                                 crypto_ablkcipher_decrypt(req));
1084                 end = get_cycles();
1085
1086                 if (ret)
1087                         goto out;
1088
1089                 cycles += end - start;
1090         }
1091
1092 out:
1093         if (ret == 0)
1094                 pr_cont("1 operation in %lu cycles (%d bytes)\n",
1095                         (cycles + 4) / 8, blen);
1096
1097         return ret;
1098 }
1099
1100 static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
1101                                struct cipher_speed_template *template,
1102                                unsigned int tcount, u8 *keysize)
1103 {
1104         unsigned int ret, i, j, k, iv_len;
1105         struct tcrypt_result tresult;
1106         const char *key;
1107         char iv[128];
1108         struct ablkcipher_request *req;
1109         struct crypto_ablkcipher *tfm;
1110         const char *e;
1111         u32 *b_size;
1112
1113         if (enc == ENCRYPT)
1114                 e = "encryption";
1115         else
1116                 e = "decryption";
1117
1118         init_completion(&tresult.completion);
1119
1120         tfm = crypto_alloc_ablkcipher(algo, 0, 0);
1121
1122         if (IS_ERR(tfm)) {
1123                 pr_err("failed to load transform for %s: %ld\n", algo,
1124                        PTR_ERR(tfm));
1125                 return;
1126         }
1127
1128         pr_info("\ntesting speed of async %s (%s) %s\n", algo,
1129                         get_driver_name(crypto_ablkcipher, tfm), e);
1130
1131         req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
1132         if (!req) {
1133                 pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
1134                        algo);
1135                 goto out;
1136         }
1137
1138         ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1139                                         tcrypt_complete, &tresult);
1140
1141         i = 0;
1142         do {
1143                 b_size = block_sizes;
1144
1145                 do {
1146                         struct scatterlist sg[TVMEMSIZE];
1147
1148                         if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
1149                                 pr_err("template (%u) too big for "
1150                                        "tvmem (%lu)\n", *keysize + *b_size,
1151                                        TVMEMSIZE * PAGE_SIZE);
1152                                 goto out_free_req;
1153                         }
1154
1155                         pr_info("test %u (%d bit key, %d byte blocks): ", i,
1156                                 *keysize * 8, *b_size);
1157
1158                         memset(tvmem[0], 0xff, PAGE_SIZE);
1159
1160                         /* set key, plain text and IV */
1161                         key = tvmem[0];
1162                         for (j = 0; j < tcount; j++) {
1163                                 if (template[j].klen == *keysize) {
1164                                         key = template[j].key;
1165                                         break;
1166                                 }
1167                         }
1168
1169                         crypto_ablkcipher_clear_flags(tfm, ~0);
1170
1171                         ret = crypto_ablkcipher_setkey(tfm, key, *keysize);
1172                         if (ret) {
1173                                 pr_err("setkey() failed flags=%x\n",
1174                                         crypto_ablkcipher_get_flags(tfm));
1175                                 goto out_free_req;
1176                         }
1177
1178                         k = *keysize + *b_size;
1179                         sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE));
1180
1181                         if (k > PAGE_SIZE) {
1182                                 sg_set_buf(sg, tvmem[0] + *keysize,
1183                                    PAGE_SIZE - *keysize);
1184                                 k -= PAGE_SIZE;
1185                                 j = 1;
1186                                 while (k > PAGE_SIZE) {
1187                                         sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
1188                                         memset(tvmem[j], 0xff, PAGE_SIZE);
1189                                         j++;
1190                                         k -= PAGE_SIZE;
1191                                 }
1192                                 sg_set_buf(sg + j, tvmem[j], k);
1193                                 memset(tvmem[j], 0xff, k);
1194                         } else {
1195                                 sg_set_buf(sg, tvmem[0] + *keysize, *b_size);
1196                         }
1197
1198                         iv_len = crypto_ablkcipher_ivsize(tfm);
1199                         if (iv_len)
1200                                 memset(&iv, 0xff, iv_len);
1201
1202                         ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv);
1203
1204                         if (secs)
1205                                 ret = test_acipher_jiffies(req, enc,
1206                                                            *b_size, secs);
1207                         else
1208                                 ret = test_acipher_cycles(req, enc,
1209                                                           *b_size);
1210
1211                         if (ret) {
1212                                 pr_err("%s() failed flags=%x\n", e,
1213                                         crypto_ablkcipher_get_flags(tfm));
1214                                 break;
1215                         }
1216                         b_size++;
1217                         i++;
1218                 } while (*b_size);
1219                 keysize++;
1220         } while (*keysize);
1221
1222 out_free_req:
1223         ablkcipher_request_free(req);
1224 out:
1225         crypto_free_ablkcipher(tfm);
1226 }
1227
1228 static void test_available(void)
1229 {
1230         char **name = check;
1231
1232         while (*name) {
1233                 printk("alg %s ", *name);
1234                 printk(crypto_has_alg(*name, 0, 0) ?
1235                        "found\n" : "not found\n");
1236                 name++;
1237         }
1238 }
1239
1240 static inline int tcrypt_test(const char *alg)
1241 {
1242         int ret;
1243
1244         ret = alg_test(alg, alg, 0, 0);
1245         /* non-fips algs return -EINVAL in fips mode */
1246         if (fips_enabled && ret == -EINVAL)
1247                 ret = 0;
1248         return ret;
1249 }
1250
1251 static int do_test(const char *alg, u32 type, u32 mask, int m)
1252 {
1253         int i;
1254         int ret = 0;
1255
1256         switch (m) {
1257         case 0:
1258                 if (alg) {
1259                         if (!crypto_has_alg(alg, type,
1260                                             mask ?: CRYPTO_ALG_TYPE_MASK))
1261                                 ret = -ENOENT;
1262                         break;
1263                 }
1264
1265                 for (i = 1; i < 200; i++)
1266                         ret += do_test(NULL, 0, 0, i);
1267                 break;
1268
1269         case 1:
1270                 ret += tcrypt_test("md5");
1271                 break;
1272
1273         case 2:
1274                 ret += tcrypt_test("sha1");
1275                 break;
1276
1277         case 3:
1278                 ret += tcrypt_test("ecb(des)");
1279                 ret += tcrypt_test("cbc(des)");
1280                 ret += tcrypt_test("ctr(des)");
1281                 break;
1282
1283         case 4:
1284                 ret += tcrypt_test("ecb(des3_ede)");
1285                 ret += tcrypt_test("cbc(des3_ede)");
1286                 ret += tcrypt_test("ctr(des3_ede)");
1287                 break;
1288
1289         case 5:
1290                 ret += tcrypt_test("md4");
1291                 break;
1292
1293         case 6:
1294                 ret += tcrypt_test("sha256");
1295                 break;
1296
1297         case 7:
1298                 ret += tcrypt_test("ecb(blowfish)");
1299                 ret += tcrypt_test("cbc(blowfish)");
1300                 ret += tcrypt_test("ctr(blowfish)");
1301                 break;
1302
1303         case 8:
1304                 ret += tcrypt_test("ecb(twofish)");
1305                 ret += tcrypt_test("cbc(twofish)");
1306                 ret += tcrypt_test("ctr(twofish)");
1307                 ret += tcrypt_test("lrw(twofish)");
1308                 ret += tcrypt_test("xts(twofish)");
1309                 break;
1310
1311         case 9:
1312                 ret += tcrypt_test("ecb(serpent)");
1313                 ret += tcrypt_test("cbc(serpent)");
1314                 ret += tcrypt_test("ctr(serpent)");
1315                 ret += tcrypt_test("lrw(serpent)");
1316                 ret += tcrypt_test("xts(serpent)");
1317                 break;
1318
1319         case 10:
1320                 ret += tcrypt_test("ecb(aes)");
1321                 ret += tcrypt_test("cbc(aes)");
1322                 ret += tcrypt_test("lrw(aes)");
1323                 ret += tcrypt_test("xts(aes)");
1324                 ret += tcrypt_test("ctr(aes)");
1325                 ret += tcrypt_test("rfc3686(ctr(aes))");
1326                 break;
1327
1328         case 11:
1329                 ret += tcrypt_test("sha384");
1330                 break;
1331
1332         case 12:
1333                 ret += tcrypt_test("sha512");
1334                 break;
1335
1336         case 13:
1337                 ret += tcrypt_test("deflate");
1338                 break;
1339
1340         case 14:
1341                 ret += tcrypt_test("ecb(cast5)");
1342                 ret += tcrypt_test("cbc(cast5)");
1343                 ret += tcrypt_test("ctr(cast5)");
1344                 break;
1345
1346         case 15:
1347                 ret += tcrypt_test("ecb(cast6)");
1348                 ret += tcrypt_test("cbc(cast6)");
1349                 ret += tcrypt_test("ctr(cast6)");
1350                 ret += tcrypt_test("lrw(cast6)");
1351                 ret += tcrypt_test("xts(cast6)");
1352                 break;
1353
1354         case 16:
1355                 ret += tcrypt_test("ecb(arc4)");
1356                 break;
1357
1358         case 17:
1359                 ret += tcrypt_test("michael_mic");
1360                 break;
1361
1362         case 18:
1363                 ret += tcrypt_test("crc32c");
1364                 break;
1365
1366         case 19:
1367                 ret += tcrypt_test("ecb(tea)");
1368                 break;
1369
1370         case 20:
1371                 ret += tcrypt_test("ecb(xtea)");
1372                 break;
1373
1374         case 21:
1375                 ret += tcrypt_test("ecb(khazad)");
1376                 break;
1377
1378         case 22:
1379                 ret += tcrypt_test("wp512");
1380                 break;
1381
1382         case 23:
1383                 ret += tcrypt_test("wp384");
1384                 break;
1385
1386         case 24:
1387                 ret += tcrypt_test("wp256");
1388                 break;
1389
1390         case 25:
1391                 ret += tcrypt_test("ecb(tnepres)");
1392                 break;
1393
1394         case 26:
1395                 ret += tcrypt_test("ecb(anubis)");
1396                 ret += tcrypt_test("cbc(anubis)");
1397                 break;
1398
1399         case 27:
1400                 ret += tcrypt_test("tgr192");
1401                 break;
1402
1403         case 28:
1404                 ret += tcrypt_test("tgr160");
1405                 break;
1406
1407         case 29:
1408                 ret += tcrypt_test("tgr128");
1409                 break;
1410
1411         case 30:
1412                 ret += tcrypt_test("ecb(xeta)");
1413                 break;
1414
1415         case 31:
1416                 ret += tcrypt_test("pcbc(fcrypt)");
1417                 break;
1418
1419         case 32:
1420                 ret += tcrypt_test("ecb(camellia)");
1421                 ret += tcrypt_test("cbc(camellia)");
1422                 ret += tcrypt_test("ctr(camellia)");
1423                 ret += tcrypt_test("lrw(camellia)");
1424                 ret += tcrypt_test("xts(camellia)");
1425                 break;
1426
1427         case 33:
1428                 ret += tcrypt_test("sha224");
1429                 break;
1430
1431         case 34:
1432                 ret += tcrypt_test("salsa20");
1433                 break;
1434
1435         case 35:
1436                 ret += tcrypt_test("gcm(aes)");
1437                 break;
1438
1439         case 36:
1440                 ret += tcrypt_test("lzo");
1441                 break;
1442
1443         case 37:
1444                 ret += tcrypt_test("ccm(aes)");
1445                 break;
1446
1447         case 38:
1448                 ret += tcrypt_test("cts(cbc(aes))");
1449                 break;
1450
1451         case 39:
1452                 ret += tcrypt_test("rmd128");
1453                 break;
1454
1455         case 40:
1456                 ret += tcrypt_test("rmd160");
1457                 break;
1458
1459         case 41:
1460                 ret += tcrypt_test("rmd256");
1461                 break;
1462
1463         case 42:
1464                 ret += tcrypt_test("rmd320");
1465                 break;
1466
1467         case 43:
1468                 ret += tcrypt_test("ecb(seed)");
1469                 break;
1470
1471         case 44:
1472                 ret += tcrypt_test("zlib");
1473                 break;
1474
1475         case 45:
1476                 ret += tcrypt_test("rfc4309(ccm(aes))");
1477                 break;
1478
1479         case 46:
1480                 ret += tcrypt_test("ghash");
1481                 break;
1482
1483         case 47:
1484                 ret += tcrypt_test("crct10dif");
1485                 break;
1486
1487         case 100:
1488                 ret += tcrypt_test("hmac(md5)");
1489                 break;
1490
1491         case 101:
1492                 ret += tcrypt_test("hmac(sha1)");
1493                 break;
1494
1495         case 102:
1496                 ret += tcrypt_test("hmac(sha256)");
1497                 break;
1498
1499         case 103:
1500                 ret += tcrypt_test("hmac(sha384)");
1501                 break;
1502
1503         case 104:
1504                 ret += tcrypt_test("hmac(sha512)");
1505                 break;
1506
1507         case 105:
1508                 ret += tcrypt_test("hmac(sha224)");
1509                 break;
1510
1511         case 106:
1512                 ret += tcrypt_test("xcbc(aes)");
1513                 break;
1514
1515         case 107:
1516                 ret += tcrypt_test("hmac(rmd128)");
1517                 break;
1518
1519         case 108:
1520                 ret += tcrypt_test("hmac(rmd160)");
1521                 break;
1522
1523         case 109:
1524                 ret += tcrypt_test("vmac(aes)");
1525                 break;
1526
1527         case 110:
1528                 ret += tcrypt_test("hmac(crc32)");
1529                 break;
1530
1531         case 150:
1532                 ret += tcrypt_test("ansi_cprng");
1533                 break;
1534
1535         case 151:
1536                 ret += tcrypt_test("rfc4106(gcm(aes))");
1537                 break;
1538
1539         case 152:
1540                 ret += tcrypt_test("rfc4543(gcm(aes))");
1541                 break;
1542
1543         case 153:
1544                 ret += tcrypt_test("cmac(aes)");
1545                 break;
1546
1547         case 154:
1548                 ret += tcrypt_test("cmac(des3_ede)");
1549                 break;
1550
1551         case 155:
1552                 ret += tcrypt_test("authenc(hmac(sha1),cbc(aes))");
1553                 break;
1554
1555         case 156:
1556                 ret += tcrypt_test("authenc(hmac(md5),ecb(cipher_null))");
1557                 break;
1558
1559         case 157:
1560                 ret += tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))");
1561                 break;
1562         case 181:
1563                 ret += tcrypt_test("authenc(hmac(sha1),cbc(des))");
1564                 break;
1565         case 182:
1566                 ret += tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))");
1567                 break;
1568         case 183:
1569                 ret += tcrypt_test("authenc(hmac(sha224),cbc(des))");
1570                 break;
1571         case 184:
1572                 ret += tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))");
1573                 break;
1574         case 185:
1575                 ret += tcrypt_test("authenc(hmac(sha256),cbc(des))");
1576                 break;
1577         case 186:
1578                 ret += tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))");
1579                 break;
1580         case 187:
1581                 ret += tcrypt_test("authenc(hmac(sha384),cbc(des))");
1582                 break;
1583         case 188:
1584                 ret += tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))");
1585                 break;
1586         case 189:
1587                 ret += tcrypt_test("authenc(hmac(sha512),cbc(des))");
1588                 break;
1589         case 190:
1590                 ret += tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))");
1591                 break;
1592         case 200:
1593                 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1594                                 speed_template_16_24_32);
1595                 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1596                                 speed_template_16_24_32);
1597                 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1598                                 speed_template_16_24_32);
1599                 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1600                                 speed_template_16_24_32);
1601                 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1602                                 speed_template_32_40_48);
1603                 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1604                                 speed_template_32_40_48);
1605                 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1606                                 speed_template_32_48_64);
1607                 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1608                                 speed_template_32_48_64);
1609                 test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1610                                 speed_template_16_24_32);
1611                 test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1612                                 speed_template_16_24_32);
1613                 break;
1614
1615         case 201:
1616                 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1617                                 des3_speed_template, DES3_SPEED_VECTORS,
1618                                 speed_template_24);
1619                 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1620                                 des3_speed_template, DES3_SPEED_VECTORS,
1621                                 speed_template_24);
1622                 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1623                                 des3_speed_template, DES3_SPEED_VECTORS,
1624                                 speed_template_24);
1625                 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1626                                 des3_speed_template, DES3_SPEED_VECTORS,
1627                                 speed_template_24);
1628                 test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec,
1629                                 des3_speed_template, DES3_SPEED_VECTORS,
1630                                 speed_template_24);
1631                 test_cipher_speed("ctr(des3_ede)", DECRYPT, sec,
1632                                 des3_speed_template, DES3_SPEED_VECTORS,
1633                                 speed_template_24);
1634                 break;
1635
1636         case 202:
1637                 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1638                                 speed_template_16_24_32);
1639                 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1640                                 speed_template_16_24_32);
1641                 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1642                                 speed_template_16_24_32);
1643                 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1644                                 speed_template_16_24_32);
1645                 test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1646                                 speed_template_16_24_32);
1647                 test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1648                                 speed_template_16_24_32);
1649                 test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1650                                 speed_template_32_40_48);
1651                 test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1652                                 speed_template_32_40_48);
1653                 test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1654                                 speed_template_32_48_64);
1655                 test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1656                                 speed_template_32_48_64);
1657                 break;
1658
1659         case 203:
1660                 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1661                                   speed_template_8_32);
1662                 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1663                                   speed_template_8_32);
1664                 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1665                                   speed_template_8_32);
1666                 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1667                                   speed_template_8_32);
1668                 test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
1669                                   speed_template_8_32);
1670                 test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
1671                                   speed_template_8_32);
1672                 break;
1673
1674         case 204:
1675                 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1676                                   speed_template_8);
1677                 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1678                                   speed_template_8);
1679                 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1680                                   speed_template_8);
1681                 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1682                                   speed_template_8);
1683                 break;
1684
1685         case 205:
1686                 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1687                                 speed_template_16_24_32);
1688                 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1689                                 speed_template_16_24_32);
1690                 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1691                                 speed_template_16_24_32);
1692                 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1693                                 speed_template_16_24_32);
1694                 test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
1695                                 speed_template_16_24_32);
1696                 test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
1697                                 speed_template_16_24_32);
1698                 test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
1699                                 speed_template_32_40_48);
1700                 test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
1701                                 speed_template_32_40_48);
1702                 test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
1703                                 speed_template_32_48_64);
1704                 test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
1705                                 speed_template_32_48_64);
1706                 break;
1707
1708         case 206:
1709                 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1710                                   speed_template_16_32);
1711                 break;
1712
1713         case 207:
1714                 test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1715                                   speed_template_16_32);
1716                 test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1717                                   speed_template_16_32);
1718                 test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1719                                   speed_template_16_32);
1720                 test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1721                                   speed_template_16_32);
1722                 test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1723                                   speed_template_16_32);
1724                 test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1725                                   speed_template_16_32);
1726                 test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1727                                   speed_template_32_48);
1728                 test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1729                                   speed_template_32_48);
1730                 test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1731                                   speed_template_32_64);
1732                 test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1733                                   speed_template_32_64);
1734                 break;
1735
1736         case 208:
1737                 test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
1738                                   speed_template_8);
1739                 break;
1740
1741         case 209:
1742                 test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
1743                                   speed_template_8_16);
1744                 test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
1745                                   speed_template_8_16);
1746                 test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
1747                                   speed_template_8_16);
1748                 test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
1749                                   speed_template_8_16);
1750                 test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
1751                                   speed_template_8_16);
1752                 test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
1753                                   speed_template_8_16);
1754                 break;
1755
1756         case 210:
1757                 test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
1758                                   speed_template_16_32);
1759                 test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
1760                                   speed_template_16_32);
1761                 test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
1762                                   speed_template_16_32);
1763                 test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
1764                                   speed_template_16_32);
1765                 test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
1766                                   speed_template_16_32);
1767                 test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
1768                                   speed_template_16_32);
1769                 test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
1770                                   speed_template_32_48);
1771                 test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
1772                                   speed_template_32_48);
1773                 test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
1774                                   speed_template_32_64);
1775                 test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
1776                                   speed_template_32_64);
1777                 break;
1778
1779         case 211:
1780                 test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec,
1781                                 NULL, 0, 16, 16, aead_speed_template_20);
1782                 test_aead_speed("gcm(aes)", ENCRYPT, sec,
1783                                 NULL, 0, 16, 8, aead_speed_template_20);
1784                 break;
1785
1786         case 212:
1787                 test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec,
1788                                 NULL, 0, 16, 16, aead_speed_template_19);
1789                 break;
1790
1791         case 213:
1792                 test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, sec,
1793                                 NULL, 0, 16, 8, aead_speed_template_36);
1794                 break;
1795
1796         case 214:
1797                 test_cipher_speed("chacha20", ENCRYPT, sec, NULL, 0,
1798                                   speed_template_32);
1799                 break;
1800
1801
1802         case 300:
1803                 if (alg) {
1804                         test_hash_speed(alg, sec, generic_hash_speed_template);
1805                         break;
1806                 }
1807
1808                 /* fall through */
1809
1810         case 301:
1811                 test_hash_speed("md4", sec, generic_hash_speed_template);
1812                 if (mode > 300 && mode < 400) break;
1813
1814         case 302:
1815                 test_hash_speed("md5", sec, generic_hash_speed_template);
1816                 if (mode > 300 && mode < 400) break;
1817
1818         case 303:
1819                 test_hash_speed("sha1", sec, generic_hash_speed_template);
1820                 if (mode > 300 && mode < 400) break;
1821
1822         case 304:
1823                 test_hash_speed("sha256", sec, generic_hash_speed_template);
1824                 if (mode > 300 && mode < 400) break;
1825
1826         case 305:
1827                 test_hash_speed("sha384", sec, generic_hash_speed_template);
1828                 if (mode > 300 && mode < 400) break;
1829
1830         case 306:
1831                 test_hash_speed("sha512", sec, generic_hash_speed_template);
1832                 if (mode > 300 && mode < 400) break;
1833
1834         case 307:
1835                 test_hash_speed("wp256", sec, generic_hash_speed_template);
1836                 if (mode > 300 && mode < 400) break;
1837
1838         case 308:
1839                 test_hash_speed("wp384", sec, generic_hash_speed_template);
1840                 if (mode > 300 && mode < 400) break;
1841
1842         case 309:
1843                 test_hash_speed("wp512", sec, generic_hash_speed_template);
1844                 if (mode > 300 && mode < 400) break;
1845
1846         case 310:
1847                 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1848                 if (mode > 300 && mode < 400) break;
1849
1850         case 311:
1851                 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1852                 if (mode > 300 && mode < 400) break;
1853
1854         case 312:
1855                 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1856                 if (mode > 300 && mode < 400) break;
1857
1858         case 313:
1859                 test_hash_speed("sha224", sec, generic_hash_speed_template);
1860                 if (mode > 300 && mode < 400) break;
1861
1862         case 314:
1863                 test_hash_speed("rmd128", sec, generic_hash_speed_template);
1864                 if (mode > 300 && mode < 400) break;
1865
1866         case 315:
1867                 test_hash_speed("rmd160", sec, generic_hash_speed_template);
1868                 if (mode > 300 && mode < 400) break;
1869
1870         case 316:
1871                 test_hash_speed("rmd256", sec, generic_hash_speed_template);
1872                 if (mode > 300 && mode < 400) break;
1873
1874         case 317:
1875                 test_hash_speed("rmd320", sec, generic_hash_speed_template);
1876                 if (mode > 300 && mode < 400) break;
1877
1878         case 318:
1879                 test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1880                 if (mode > 300 && mode < 400) break;
1881
1882         case 319:
1883                 test_hash_speed("crc32c", sec, generic_hash_speed_template);
1884                 if (mode > 300 && mode < 400) break;
1885
1886         case 320:
1887                 test_hash_speed("crct10dif", sec, generic_hash_speed_template);
1888                 if (mode > 300 && mode < 400) break;
1889
1890         case 321:
1891                 test_hash_speed("poly1305", sec, poly1305_speed_template);
1892                 if (mode > 300 && mode < 400) break;
1893
1894         case 399:
1895                 break;
1896
1897         case 400:
1898                 if (alg) {
1899                         test_ahash_speed(alg, sec, generic_hash_speed_template);
1900                         break;
1901                 }
1902
1903                 /* fall through */
1904
1905         case 401:
1906                 test_ahash_speed("md4", sec, generic_hash_speed_template);
1907                 if (mode > 400 && mode < 500) break;
1908
1909         case 402:
1910                 test_ahash_speed("md5", sec, generic_hash_speed_template);
1911                 if (mode > 400 && mode < 500) break;
1912
1913         case 403:
1914                 test_ahash_speed("sha1", sec, generic_hash_speed_template);
1915                 if (mode > 400 && mode < 500) break;
1916
1917         case 404:
1918                 test_ahash_speed("sha256", sec, generic_hash_speed_template);
1919                 if (mode > 400 && mode < 500) break;
1920
1921         case 405:
1922                 test_ahash_speed("sha384", sec, generic_hash_speed_template);
1923                 if (mode > 400 && mode < 500) break;
1924
1925         case 406:
1926                 test_ahash_speed("sha512", sec, generic_hash_speed_template);
1927                 if (mode > 400 && mode < 500) break;
1928
1929         case 407:
1930                 test_ahash_speed("wp256", sec, generic_hash_speed_template);
1931                 if (mode > 400 && mode < 500) break;
1932
1933         case 408:
1934                 test_ahash_speed("wp384", sec, generic_hash_speed_template);
1935                 if (mode > 400 && mode < 500) break;
1936
1937         case 409:
1938                 test_ahash_speed("wp512", sec, generic_hash_speed_template);
1939                 if (mode > 400 && mode < 500) break;
1940
1941         case 410:
1942                 test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1943                 if (mode > 400 && mode < 500) break;
1944
1945         case 411:
1946                 test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1947                 if (mode > 400 && mode < 500) break;
1948
1949         case 412:
1950                 test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1951                 if (mode > 400 && mode < 500) break;
1952
1953         case 413:
1954                 test_ahash_speed("sha224", sec, generic_hash_speed_template);
1955                 if (mode > 400 && mode < 500) break;
1956
1957         case 414:
1958                 test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1959                 if (mode > 400 && mode < 500) break;
1960
1961         case 415:
1962                 test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1963                 if (mode > 400 && mode < 500) break;
1964
1965         case 416:
1966                 test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1967                 if (mode > 400 && mode < 500) break;
1968
1969         case 417:
1970                 test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1971                 if (mode > 400 && mode < 500) break;
1972
1973         case 499:
1974                 break;
1975
1976         case 500:
1977                 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1978                                    speed_template_16_24_32);
1979                 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1980                                    speed_template_16_24_32);
1981                 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1982                                    speed_template_16_24_32);
1983                 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1984                                    speed_template_16_24_32);
1985                 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1986                                    speed_template_32_40_48);
1987                 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1988                                    speed_template_32_40_48);
1989                 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1990                                    speed_template_32_48_64);
1991                 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1992                                    speed_template_32_48_64);
1993                 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1994                                    speed_template_16_24_32);
1995                 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1996                                    speed_template_16_24_32);
1997                 test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
1998                                    speed_template_16_24_32);
1999                 test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
2000                                    speed_template_16_24_32);
2001                 test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
2002                                    speed_template_16_24_32);
2003                 test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
2004                                    speed_template_16_24_32);
2005                 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0,
2006                                    speed_template_20_28_36);
2007                 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0,
2008                                    speed_template_20_28_36);
2009                 break;
2010
2011         case 501:
2012                 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
2013                                    des3_speed_template, DES3_SPEED_VECTORS,
2014                                    speed_template_24);
2015                 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
2016                                    des3_speed_template, DES3_SPEED_VECTORS,
2017                                    speed_template_24);
2018                 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
2019                                    des3_speed_template, DES3_SPEED_VECTORS,
2020                                    speed_template_24);
2021                 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
2022                                    des3_speed_template, DES3_SPEED_VECTORS,
2023                                    speed_template_24);
2024                 test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec,
2025                                    des3_speed_template, DES3_SPEED_VECTORS,
2026                                    speed_template_24);
2027                 test_acipher_speed("cfb(des3_ede)", DECRYPT, sec,
2028                                    des3_speed_template, DES3_SPEED_VECTORS,
2029                                    speed_template_24);
2030                 test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec,
2031                                    des3_speed_template, DES3_SPEED_VECTORS,
2032                                    speed_template_24);
2033                 test_acipher_speed("ofb(des3_ede)", DECRYPT, sec,
2034                                    des3_speed_template, DES3_SPEED_VECTORS,
2035                                    speed_template_24);
2036                 break;
2037
2038         case 502:
2039                 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
2040                                    speed_template_8);
2041                 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
2042                                    speed_template_8);
2043                 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
2044                                    speed_template_8);
2045                 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
2046                                    speed_template_8);
2047                 test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
2048                                    speed_template_8);
2049                 test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
2050                                    speed_template_8);
2051                 test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
2052                                    speed_template_8);
2053                 test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
2054                                    speed_template_8);
2055                 break;
2056
2057         case 503:
2058                 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
2059                                    speed_template_16_32);
2060                 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
2061                                    speed_template_16_32);
2062                 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2063                                    speed_template_16_32);
2064                 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2065                                    speed_template_16_32);
2066                 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2067                                    speed_template_16_32);
2068                 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2069                                    speed_template_16_32);
2070                 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2071                                    speed_template_32_48);
2072                 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2073                                    speed_template_32_48);
2074                 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2075                                    speed_template_32_64);
2076                 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2077                                    speed_template_32_64);
2078                 break;
2079
2080         case 504:
2081                 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2082                                    speed_template_16_24_32);
2083                 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2084                                    speed_template_16_24_32);
2085                 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2086                                    speed_template_16_24_32);
2087                 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2088                                    speed_template_16_24_32);
2089                 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2090                                    speed_template_16_24_32);
2091                 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2092                                    speed_template_16_24_32);
2093                 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2094                                    speed_template_32_40_48);
2095                 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2096                                    speed_template_32_40_48);
2097                 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2098                                    speed_template_32_48_64);
2099                 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2100                                    speed_template_32_48_64);
2101                 break;
2102
2103         case 505:
2104                 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2105                                    speed_template_8);
2106                 break;
2107
2108         case 506:
2109                 test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2110                                    speed_template_8_16);
2111                 test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2112                                    speed_template_8_16);
2113                 test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2114                                    speed_template_8_16);
2115                 test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2116                                    speed_template_8_16);
2117                 test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2118                                    speed_template_8_16);
2119                 test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2120                                    speed_template_8_16);
2121                 break;
2122
2123         case 507:
2124                 test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2125                                    speed_template_16_32);
2126                 test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2127                                    speed_template_16_32);
2128                 test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2129                                    speed_template_16_32);
2130                 test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2131                                    speed_template_16_32);
2132                 test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2133                                    speed_template_16_32);
2134                 test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2135                                    speed_template_16_32);
2136                 test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2137                                    speed_template_32_48);
2138                 test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2139                                    speed_template_32_48);
2140                 test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2141                                    speed_template_32_64);
2142                 test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2143                                    speed_template_32_64);
2144                 break;
2145
2146         case 508:
2147                 test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2148                                    speed_template_16_32);
2149                 test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2150                                    speed_template_16_32);
2151                 test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2152                                    speed_template_16_32);
2153                 test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2154                                    speed_template_16_32);
2155                 test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2156                                    speed_template_16_32);
2157                 test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2158                                    speed_template_16_32);
2159                 test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2160                                    speed_template_32_48);
2161                 test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2162                                    speed_template_32_48);
2163                 test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2164                                    speed_template_32_64);
2165                 test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2166                                    speed_template_32_64);
2167                 break;
2168
2169         case 509:
2170                 test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2171                                    speed_template_8_32);
2172                 test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2173                                    speed_template_8_32);
2174                 test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2175                                    speed_template_8_32);
2176                 test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2177                                    speed_template_8_32);
2178                 test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2179                                    speed_template_8_32);
2180                 test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2181                                    speed_template_8_32);
2182                 break;
2183
2184         case 1000:
2185                 test_available();
2186                 break;
2187         }
2188
2189         return ret;
2190 }
2191
2192 static int __init tcrypt_mod_init(void)
2193 {
2194         int err = -ENOMEM;
2195         int i;
2196
2197         for (i = 0; i < TVMEMSIZE; i++) {
2198                 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
2199                 if (!tvmem[i])
2200                         goto err_free_tv;
2201         }
2202
2203         err = do_test(alg, type, mask, mode);
2204
2205         if (err) {
2206                 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
2207                 goto err_free_tv;
2208         }
2209
2210         /* We intentionaly return -EAGAIN to prevent keeping the module,
2211          * unless we're running in fips mode. It does all its work from
2212          * init() and doesn't offer any runtime functionality, but in
2213          * the fips case, checking for a successful load is helpful.
2214          * => we don't need it in the memory, do we?
2215          *                                        -- mludvig
2216          */
2217         if (!fips_enabled)
2218                 err = -EAGAIN;
2219
2220 err_free_tv:
2221         for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
2222                 free_page((unsigned long)tvmem[i]);
2223
2224         return err;
2225 }
2226
2227 /*
2228  * If an init function is provided, an exit function must also be provided
2229  * to allow module unload.
2230  */
2231 static void __exit tcrypt_mod_fini(void) { }
2232
2233 module_init(tcrypt_mod_init);
2234 module_exit(tcrypt_mod_fini);
2235
2236 module_param(alg, charp, 0);
2237 module_param(type, uint, 0);
2238 module_param(mask, uint, 0);
2239 module_param(mode, int, 0);
2240 module_param(sec, uint, 0);
2241 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
2242                       "(defaults to zero which uses CPU cycles instead)");
2243
2244 MODULE_LICENSE("GPL");
2245 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2246 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");