Back to home page

LXR

 
 

    


0001 /*
0002  * Quick & dirty crypto testing module.
0003  *
0004  * This will only exist until we have a better testing mechanism
0005  * (e.g. a char device).
0006  *
0007  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
0008  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
0009  * Copyright (c) 2007 Nokia Siemens Networks
0010  *
0011  * Updated RFC4106 AES-GCM testing.
0012  *    Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
0013  *             Adrian Hoban <adrian.hoban@intel.com>
0014  *             Gabriele Paoloni <gabriele.paoloni@intel.com>
0015  *             Tadeusz Struk (tadeusz.struk@intel.com)
0016  *             Copyright (c) 2010, Intel Corporation.
0017  *
0018  * This program is free software; you can redistribute it and/or modify it
0019  * under the terms of the GNU General Public License as published by the Free
0020  * Software Foundation; either version 2 of the License, or (at your option)
0021  * any later version.
0022  *
0023  */
0024 
0025 #include <crypto/aead.h>
0026 #include <crypto/hash.h>
0027 #include <crypto/skcipher.h>
0028 #include <linux/err.h>
0029 #include <linux/fips.h>
0030 #include <linux/init.h>
0031 #include <linux/gfp.h>
0032 #include <linux/module.h>
0033 #include <linux/scatterlist.h>
0034 #include <linux/string.h>
0035 #include <linux/moduleparam.h>
0036 #include <linux/jiffies.h>
0037 #include <linux/timex.h>
0038 #include <linux/interrupt.h>
0039 #include "tcrypt.h"
0040 
0041 /*
0042  * Need slab memory for testing (size in number of pages).
0043  */
0044 #define TVMEMSIZE   4
0045 
0046 /*
0047 * Used by test_cipher_speed()
0048 */
0049 #define ENCRYPT 1
0050 #define DECRYPT 0
0051 
0052 #define MAX_DIGEST_SIZE     64
0053 
0054 /*
0055  * return a string with the driver name
0056  */
0057 #define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm))
0058 
0059 /*
0060  * Used by test_cipher_speed()
0061  */
0062 static unsigned int sec;
0063 
0064 static char *alg = NULL;
0065 static u32 type;
0066 static u32 mask;
0067 static int mode;
0068 static char *tvmem[TVMEMSIZE];
0069 
0070 static char *check[] = {
0071     "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
0072     "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
0073     "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
0074     "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
0075     "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
0076     "lzo", "cts", "zlib", "sha3-224", "sha3-256", "sha3-384", "sha3-512",
0077     NULL
0078 };
0079 
0080 struct tcrypt_result {
0081     struct completion completion;
0082     int err;
0083 };
0084 
0085 static void tcrypt_complete(struct crypto_async_request *req, int err)
0086 {
0087     struct tcrypt_result *res = req->data;
0088 
0089     if (err == -EINPROGRESS)
0090         return;
0091 
0092     res->err = err;
0093     complete(&res->completion);
0094 }
0095 
0096 static inline int do_one_aead_op(struct aead_request *req, int ret)
0097 {
0098     if (ret == -EINPROGRESS || ret == -EBUSY) {
0099         struct tcrypt_result *tr = req->base.data;
0100 
0101         ret = wait_for_completion_interruptible(&tr->completion);
0102         if (!ret)
0103             ret = tr->err;
0104         reinit_completion(&tr->completion);
0105     }
0106 
0107     return ret;
0108 }
0109 
0110 static int test_aead_jiffies(struct aead_request *req, int enc,
0111                 int blen, int secs)
0112 {
0113     unsigned long start, end;
0114     int bcount;
0115     int ret;
0116 
0117     for (start = jiffies, end = start + secs * HZ, bcount = 0;
0118          time_before(jiffies, end); bcount++) {
0119         if (enc)
0120             ret = do_one_aead_op(req, crypto_aead_encrypt(req));
0121         else
0122             ret = do_one_aead_op(req, crypto_aead_decrypt(req));
0123 
0124         if (ret)
0125             return ret;
0126     }
0127 
0128     printk("%d operations in %d seconds (%ld bytes)\n",
0129            bcount, secs, (long)bcount * blen);
0130     return 0;
0131 }
0132 
0133 static int test_aead_cycles(struct aead_request *req, int enc, int blen)
0134 {
0135     unsigned long cycles = 0;
0136     int ret = 0;
0137     int i;
0138 
0139     local_irq_disable();
0140 
0141     /* Warm-up run. */
0142     for (i = 0; i < 4; i++) {
0143         if (enc)
0144             ret = do_one_aead_op(req, crypto_aead_encrypt(req));
0145         else
0146             ret = do_one_aead_op(req, crypto_aead_decrypt(req));
0147 
0148         if (ret)
0149             goto out;
0150     }
0151 
0152     /* The real thing. */
0153     for (i = 0; i < 8; i++) {
0154         cycles_t start, end;
0155 
0156         start = get_cycles();
0157         if (enc)
0158             ret = do_one_aead_op(req, crypto_aead_encrypt(req));
0159         else
0160             ret = do_one_aead_op(req, crypto_aead_decrypt(req));
0161         end = get_cycles();
0162 
0163         if (ret)
0164             goto out;
0165 
0166         cycles += end - start;
0167     }
0168 
0169 out:
0170     local_irq_enable();
0171 
0172     if (ret == 0)
0173         printk("1 operation in %lu cycles (%d bytes)\n",
0174                (cycles + 4) / 8, blen);
0175 
0176     return ret;
0177 }
0178 
0179 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
0180 static u32 aead_sizes[] = { 16, 64, 256, 512, 1024, 2048, 4096, 8192, 0 };
0181 
0182 #define XBUFSIZE 8
0183 #define MAX_IVLEN 32
0184 
0185 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
0186 {
0187     int i;
0188 
0189     for (i = 0; i < XBUFSIZE; i++) {
0190         buf[i] = (void *)__get_free_page(GFP_KERNEL);
0191         if (!buf[i])
0192             goto err_free_buf;
0193     }
0194 
0195     return 0;
0196 
0197 err_free_buf:
0198     while (i-- > 0)
0199         free_page((unsigned long)buf[i]);
0200 
0201     return -ENOMEM;
0202 }
0203 
0204 static void testmgr_free_buf(char *buf[XBUFSIZE])
0205 {
0206     int i;
0207 
0208     for (i = 0; i < XBUFSIZE; i++)
0209         free_page((unsigned long)buf[i]);
0210 }
0211 
0212 static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE],
0213             unsigned int buflen)
0214 {
0215     int np = (buflen + PAGE_SIZE - 1)/PAGE_SIZE;
0216     int k, rem;
0217 
0218     if (np > XBUFSIZE) {
0219         rem = PAGE_SIZE;
0220         np = XBUFSIZE;
0221     } else {
0222         rem = buflen % PAGE_SIZE;
0223     }
0224 
0225     sg_init_table(sg, np + 1);
0226     np--;
0227     for (k = 0; k < np; k++)
0228         sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE);
0229 
0230     sg_set_buf(&sg[k + 1], xbuf[k], rem);
0231 }
0232 
0233 static void test_aead_speed(const char *algo, int enc, unsigned int secs,
0234                 struct aead_speed_template *template,
0235                 unsigned int tcount, u8 authsize,
0236                 unsigned int aad_size, u8 *keysize)
0237 {
0238     unsigned int i, j;
0239     struct crypto_aead *tfm;
0240     int ret = -ENOMEM;
0241     const char *key;
0242     struct aead_request *req;
0243     struct scatterlist *sg;
0244     struct scatterlist *sgout;
0245     const char *e;
0246     void *assoc;
0247     char *iv;
0248     char *xbuf[XBUFSIZE];
0249     char *xoutbuf[XBUFSIZE];
0250     char *axbuf[XBUFSIZE];
0251     unsigned int *b_size;
0252     unsigned int iv_len;
0253     struct tcrypt_result result;
0254 
0255     iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
0256     if (!iv)
0257         return;
0258 
0259     if (aad_size >= PAGE_SIZE) {
0260         pr_err("associate data length (%u) too big\n", aad_size);
0261         goto out_noxbuf;
0262     }
0263 
0264     if (enc == ENCRYPT)
0265         e = "encryption";
0266     else
0267         e = "decryption";
0268 
0269     if (testmgr_alloc_buf(xbuf))
0270         goto out_noxbuf;
0271     if (testmgr_alloc_buf(axbuf))
0272         goto out_noaxbuf;
0273     if (testmgr_alloc_buf(xoutbuf))
0274         goto out_nooutbuf;
0275 
0276     sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL);
0277     if (!sg)
0278         goto out_nosg;
0279     sgout = &sg[9];
0280 
0281     tfm = crypto_alloc_aead(algo, 0, 0);
0282 
0283     if (IS_ERR(tfm)) {
0284         pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo,
0285                PTR_ERR(tfm));
0286         goto out_notfm;
0287     }
0288 
0289     init_completion(&result.completion);
0290     printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
0291             get_driver_name(crypto_aead, tfm), e);
0292 
0293     req = aead_request_alloc(tfm, GFP_KERNEL);
0294     if (!req) {
0295         pr_err("alg: aead: Failed to allocate request for %s\n",
0296                algo);
0297         goto out_noreq;
0298     }
0299 
0300     aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
0301                   tcrypt_complete, &result);
0302 
0303     i = 0;
0304     do {
0305         b_size = aead_sizes;
0306         do {
0307             assoc = axbuf[0];
0308             memset(assoc, 0xff, aad_size);
0309 
0310             if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
0311                 pr_err("template (%u) too big for tvmem (%lu)\n",
0312                        *keysize + *b_size,
0313                     TVMEMSIZE * PAGE_SIZE);
0314                 goto out;
0315             }
0316 
0317             key = tvmem[0];
0318             for (j = 0; j < tcount; j++) {
0319                 if (template[j].klen == *keysize) {
0320                     key = template[j].key;
0321                     break;
0322                 }
0323             }
0324             ret = crypto_aead_setkey(tfm, key, *keysize);
0325             ret = crypto_aead_setauthsize(tfm, authsize);
0326 
0327             iv_len = crypto_aead_ivsize(tfm);
0328             if (iv_len)
0329                 memset(iv, 0xff, iv_len);
0330 
0331             crypto_aead_clear_flags(tfm, ~0);
0332             printk(KERN_INFO "test %u (%d bit key, %d byte blocks): ",
0333                     i, *keysize * 8, *b_size);
0334 
0335 
0336             memset(tvmem[0], 0xff, PAGE_SIZE);
0337 
0338             if (ret) {
0339                 pr_err("setkey() failed flags=%x\n",
0340                         crypto_aead_get_flags(tfm));
0341                 goto out;
0342             }
0343 
0344             sg_init_aead(sg, xbuf,
0345                     *b_size + (enc ? authsize : 0));
0346 
0347             sg_init_aead(sgout, xoutbuf,
0348                     *b_size + (enc ? authsize : 0));
0349 
0350             sg_set_buf(&sg[0], assoc, aad_size);
0351             sg_set_buf(&sgout[0], assoc, aad_size);
0352 
0353             aead_request_set_crypt(req, sg, sgout, *b_size, iv);
0354             aead_request_set_ad(req, aad_size);
0355 
0356             if (secs)
0357                 ret = test_aead_jiffies(req, enc, *b_size,
0358                             secs);
0359             else
0360                 ret = test_aead_cycles(req, enc, *b_size);
0361 
0362             if (ret) {
0363                 pr_err("%s() failed return code=%d\n", e, ret);
0364                 break;
0365             }
0366             b_size++;
0367             i++;
0368         } while (*b_size);
0369         keysize++;
0370     } while (*keysize);
0371 
0372 out:
0373     aead_request_free(req);
0374 out_noreq:
0375     crypto_free_aead(tfm);
0376 out_notfm:
0377     kfree(sg);
0378 out_nosg:
0379     testmgr_free_buf(xoutbuf);
0380 out_nooutbuf:
0381     testmgr_free_buf(axbuf);
0382 out_noaxbuf:
0383     testmgr_free_buf(xbuf);
0384 out_noxbuf:
0385     kfree(iv);
0386     return;
0387 }
0388 
0389 static void test_hash_sg_init(struct scatterlist *sg)
0390 {
0391     int i;
0392 
0393     sg_init_table(sg, TVMEMSIZE);
0394     for (i = 0; i < TVMEMSIZE; i++) {
0395         sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
0396         memset(tvmem[i], 0xff, PAGE_SIZE);
0397     }
0398 }
0399 
0400 static inline int do_one_ahash_op(struct ahash_request *req, int ret)
0401 {
0402     if (ret == -EINPROGRESS || ret == -EBUSY) {
0403         struct tcrypt_result *tr = req->base.data;
0404 
0405         wait_for_completion(&tr->completion);
0406         reinit_completion(&tr->completion);
0407         ret = tr->err;
0408     }
0409     return ret;
0410 }
0411 
0412 struct test_mb_ahash_data {
0413     struct scatterlist sg[TVMEMSIZE];
0414     char result[64];
0415     struct ahash_request *req;
0416     struct tcrypt_result tresult;
0417     char *xbuf[XBUFSIZE];
0418 };
0419 
0420 static void test_mb_ahash_speed(const char *algo, unsigned int sec,
0421                 struct hash_speed *speed)
0422 {
0423     struct test_mb_ahash_data *data;
0424     struct crypto_ahash *tfm;
0425     unsigned long start, end;
0426     unsigned long cycles;
0427     unsigned int i, j, k;
0428     int ret;
0429 
0430     data = kzalloc(sizeof(*data) * 8, GFP_KERNEL);
0431     if (!data)
0432         return;
0433 
0434     tfm = crypto_alloc_ahash(algo, 0, 0);
0435     if (IS_ERR(tfm)) {
0436         pr_err("failed to load transform for %s: %ld\n",
0437             algo, PTR_ERR(tfm));
0438         goto free_data;
0439     }
0440 
0441     for (i = 0; i < 8; ++i) {
0442         if (testmgr_alloc_buf(data[i].xbuf))
0443             goto out;
0444 
0445         init_completion(&data[i].tresult.completion);
0446 
0447         data[i].req = ahash_request_alloc(tfm, GFP_KERNEL);
0448         if (!data[i].req) {
0449             pr_err("alg: hash: Failed to allocate request for %s\n",
0450                    algo);
0451             goto out;
0452         }
0453 
0454         ahash_request_set_callback(data[i].req, 0,
0455                        tcrypt_complete, &data[i].tresult);
0456         test_hash_sg_init(data[i].sg);
0457     }
0458 
0459     pr_info("\ntesting speed of multibuffer %s (%s)\n", algo,
0460         get_driver_name(crypto_ahash, tfm));
0461 
0462     for (i = 0; speed[i].blen != 0; i++) {
0463         /* For some reason this only tests digests. */
0464         if (speed[i].blen != speed[i].plen)
0465             continue;
0466 
0467         if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
0468             pr_err("template (%u) too big for tvmem (%lu)\n",
0469                    speed[i].blen, TVMEMSIZE * PAGE_SIZE);
0470             goto out;
0471         }
0472 
0473         if (speed[i].klen)
0474             crypto_ahash_setkey(tfm, tvmem[0], speed[i].klen);
0475 
0476         for (k = 0; k < 8; k++)
0477             ahash_request_set_crypt(data[k].req, data[k].sg,
0478                         data[k].result, speed[i].blen);
0479 
0480         pr_info("test%3u "
0481             "(%5u byte blocks,%5u bytes per update,%4u updates): ",
0482             i, speed[i].blen, speed[i].plen,
0483             speed[i].blen / speed[i].plen);
0484 
0485         start = get_cycles();
0486 
0487         for (k = 0; k < 8; k++) {
0488             ret = crypto_ahash_digest(data[k].req);
0489             if (ret == -EINPROGRESS) {
0490                 ret = 0;
0491                 continue;
0492             }
0493 
0494             if (ret)
0495                 break;
0496 
0497             complete(&data[k].tresult.completion);
0498             data[k].tresult.err = 0;
0499         }
0500 
0501         for (j = 0; j < k; j++) {
0502             struct tcrypt_result *tr = &data[j].tresult;
0503 
0504             wait_for_completion(&tr->completion);
0505             if (tr->err)
0506                 ret = tr->err;
0507         }
0508 
0509         end = get_cycles();
0510         cycles = end - start;
0511         pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
0512             cycles, cycles / (8 * speed[i].blen));
0513 
0514         if (ret) {
0515             pr_err("At least one hashing failed ret=%d\n", ret);
0516             break;
0517         }
0518     }
0519 
0520 out:
0521     for (k = 0; k < 8; ++k)
0522         ahash_request_free(data[k].req);
0523 
0524     for (k = 0; k < 8; ++k)
0525         testmgr_free_buf(data[k].xbuf);
0526 
0527     crypto_free_ahash(tfm);
0528 
0529 free_data:
0530     kfree(data);
0531 }
0532 
0533 static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
0534                      char *out, int secs)
0535 {
0536     unsigned long start, end;
0537     int bcount;
0538     int ret;
0539 
0540     for (start = jiffies, end = start + secs * HZ, bcount = 0;
0541          time_before(jiffies, end); bcount++) {
0542         ret = do_one_ahash_op(req, crypto_ahash_digest(req));
0543         if (ret)
0544             return ret;
0545     }
0546 
0547     printk("%6u opers/sec, %9lu bytes/sec\n",
0548            bcount / secs, ((long)bcount * blen) / secs);
0549 
0550     return 0;
0551 }
0552 
0553 static int test_ahash_jiffies(struct ahash_request *req, int blen,
0554                   int plen, char *out, int secs)
0555 {
0556     unsigned long start, end;
0557     int bcount, pcount;
0558     int ret;
0559 
0560     if (plen == blen)
0561         return test_ahash_jiffies_digest(req, blen, out, secs);
0562 
0563     for (start = jiffies, end = start + secs * HZ, bcount = 0;
0564          time_before(jiffies, end); bcount++) {
0565         ret = do_one_ahash_op(req, crypto_ahash_init(req));
0566         if (ret)
0567             return ret;
0568         for (pcount = 0; pcount < blen; pcount += plen) {
0569             ret = do_one_ahash_op(req, crypto_ahash_update(req));
0570             if (ret)
0571                 return ret;
0572         }
0573         /* we assume there is enough space in 'out' for the result */
0574         ret = do_one_ahash_op(req, crypto_ahash_final(req));
0575         if (ret)
0576             return ret;
0577     }
0578 
0579     pr_cont("%6u opers/sec, %9lu bytes/sec\n",
0580         bcount / secs, ((long)bcount * blen) / secs);
0581 
0582     return 0;
0583 }
0584 
0585 static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
0586                     char *out)
0587 {
0588     unsigned long cycles = 0;
0589     int ret, i;
0590 
0591     /* Warm-up run. */
0592     for (i = 0; i < 4; i++) {
0593         ret = do_one_ahash_op(req, crypto_ahash_digest(req));
0594         if (ret)
0595             goto out;
0596     }
0597 
0598     /* The real thing. */
0599     for (i = 0; i < 8; i++) {
0600         cycles_t start, end;
0601 
0602         start = get_cycles();
0603 
0604         ret = do_one_ahash_op(req, crypto_ahash_digest(req));
0605         if (ret)
0606             goto out;
0607 
0608         end = get_cycles();
0609 
0610         cycles += end - start;
0611     }
0612 
0613 out:
0614     if (ret)
0615         return ret;
0616 
0617     pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
0618         cycles / 8, cycles / (8 * blen));
0619 
0620     return 0;
0621 }
0622 
0623 static int test_ahash_cycles(struct ahash_request *req, int blen,
0624                  int plen, char *out)
0625 {
0626     unsigned long cycles = 0;
0627     int i, pcount, ret;
0628 
0629     if (plen == blen)
0630         return test_ahash_cycles_digest(req, blen, out);
0631 
0632     /* Warm-up run. */
0633     for (i = 0; i < 4; i++) {
0634         ret = do_one_ahash_op(req, crypto_ahash_init(req));
0635         if (ret)
0636             goto out;
0637         for (pcount = 0; pcount < blen; pcount += plen) {
0638             ret = do_one_ahash_op(req, crypto_ahash_update(req));
0639             if (ret)
0640                 goto out;
0641         }
0642         ret = do_one_ahash_op(req, crypto_ahash_final(req));
0643         if (ret)
0644             goto out;
0645     }
0646 
0647     /* The real thing. */
0648     for (i = 0; i < 8; i++) {
0649         cycles_t start, end;
0650 
0651         start = get_cycles();
0652 
0653         ret = do_one_ahash_op(req, crypto_ahash_init(req));
0654         if (ret)
0655             goto out;
0656         for (pcount = 0; pcount < blen; pcount += plen) {
0657             ret = do_one_ahash_op(req, crypto_ahash_update(req));
0658             if (ret)
0659                 goto out;
0660         }
0661         ret = do_one_ahash_op(req, crypto_ahash_final(req));
0662         if (ret)
0663             goto out;
0664 
0665         end = get_cycles();
0666 
0667         cycles += end - start;
0668     }
0669 
0670 out:
0671     if (ret)
0672         return ret;
0673 
0674     pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
0675         cycles / 8, cycles / (8 * blen));
0676 
0677     return 0;
0678 }
0679 
0680 static void test_ahash_speed_common(const char *algo, unsigned int secs,
0681                     struct hash_speed *speed, unsigned mask)
0682 {
0683     struct scatterlist sg[TVMEMSIZE];
0684     struct tcrypt_result tresult;
0685     struct ahash_request *req;
0686     struct crypto_ahash *tfm;
0687     char *output;
0688     int i, ret;
0689 
0690     tfm = crypto_alloc_ahash(algo, 0, mask);
0691     if (IS_ERR(tfm)) {
0692         pr_err("failed to load transform for %s: %ld\n",
0693                algo, PTR_ERR(tfm));
0694         return;
0695     }
0696 
0697     printk(KERN_INFO "\ntesting speed of async %s (%s)\n", algo,
0698             get_driver_name(crypto_ahash, tfm));
0699 
0700     if (crypto_ahash_digestsize(tfm) > MAX_DIGEST_SIZE) {
0701         pr_err("digestsize(%u) > %d\n", crypto_ahash_digestsize(tfm),
0702                MAX_DIGEST_SIZE);
0703         goto out;
0704     }
0705 
0706     test_hash_sg_init(sg);
0707     req = ahash_request_alloc(tfm, GFP_KERNEL);
0708     if (!req) {
0709         pr_err("ahash request allocation failure\n");
0710         goto out;
0711     }
0712 
0713     init_completion(&tresult.completion);
0714     ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
0715                    tcrypt_complete, &tresult);
0716 
0717     output = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
0718     if (!output)
0719         goto out_nomem;
0720 
0721     for (i = 0; speed[i].blen != 0; i++) {
0722         if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
0723             pr_err("template (%u) too big for tvmem (%lu)\n",
0724                    speed[i].blen, TVMEMSIZE * PAGE_SIZE);
0725             break;
0726         }
0727 
0728         pr_info("test%3u "
0729             "(%5u byte blocks,%5u bytes per update,%4u updates): ",
0730             i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
0731 
0732         ahash_request_set_crypt(req, sg, output, speed[i].plen);
0733 
0734         if (secs)
0735             ret = test_ahash_jiffies(req, speed[i].blen,
0736                          speed[i].plen, output, secs);
0737         else
0738             ret = test_ahash_cycles(req, speed[i].blen,
0739                         speed[i].plen, output);
0740 
0741         if (ret) {
0742             pr_err("hashing failed ret=%d\n", ret);
0743             break;
0744         }
0745     }
0746 
0747     kfree(output);
0748 
0749 out_nomem:
0750     ahash_request_free(req);
0751 
0752 out:
0753     crypto_free_ahash(tfm);
0754 }
0755 
0756 static void test_ahash_speed(const char *algo, unsigned int secs,
0757                  struct hash_speed *speed)
0758 {
0759     return test_ahash_speed_common(algo, secs, speed, 0);
0760 }
0761 
0762 static void test_hash_speed(const char *algo, unsigned int secs,
0763                 struct hash_speed *speed)
0764 {
0765     return test_ahash_speed_common(algo, secs, speed, CRYPTO_ALG_ASYNC);
0766 }
0767 
0768 static inline int do_one_acipher_op(struct skcipher_request *req, int ret)
0769 {
0770     if (ret == -EINPROGRESS || ret == -EBUSY) {
0771         struct tcrypt_result *tr = req->base.data;
0772 
0773         wait_for_completion(&tr->completion);
0774         reinit_completion(&tr->completion);
0775         ret = tr->err;
0776     }
0777 
0778     return ret;
0779 }
0780 
0781 static int test_acipher_jiffies(struct skcipher_request *req, int enc,
0782                 int blen, int secs)
0783 {
0784     unsigned long start, end;
0785     int bcount;
0786     int ret;
0787 
0788     for (start = jiffies, end = start + secs * HZ, bcount = 0;
0789          time_before(jiffies, end); bcount++) {
0790         if (enc)
0791             ret = do_one_acipher_op(req,
0792                         crypto_skcipher_encrypt(req));
0793         else
0794             ret = do_one_acipher_op(req,
0795                         crypto_skcipher_decrypt(req));
0796 
0797         if (ret)
0798             return ret;
0799     }
0800 
0801     pr_cont("%d operations in %d seconds (%ld bytes)\n",
0802         bcount, secs, (long)bcount * blen);
0803     return 0;
0804 }
0805 
0806 static int test_acipher_cycles(struct skcipher_request *req, int enc,
0807                    int blen)
0808 {
0809     unsigned long cycles = 0;
0810     int ret = 0;
0811     int i;
0812 
0813     /* Warm-up run. */
0814     for (i = 0; i < 4; i++) {
0815         if (enc)
0816             ret = do_one_acipher_op(req,
0817                         crypto_skcipher_encrypt(req));
0818         else
0819             ret = do_one_acipher_op(req,
0820                         crypto_skcipher_decrypt(req));
0821 
0822         if (ret)
0823             goto out;
0824     }
0825 
0826     /* The real thing. */
0827     for (i = 0; i < 8; i++) {
0828         cycles_t start, end;
0829 
0830         start = get_cycles();
0831         if (enc)
0832             ret = do_one_acipher_op(req,
0833                         crypto_skcipher_encrypt(req));
0834         else
0835             ret = do_one_acipher_op(req,
0836                         crypto_skcipher_decrypt(req));
0837         end = get_cycles();
0838 
0839         if (ret)
0840             goto out;
0841 
0842         cycles += end - start;
0843     }
0844 
0845 out:
0846     if (ret == 0)
0847         pr_cont("1 operation in %lu cycles (%d bytes)\n",
0848             (cycles + 4) / 8, blen);
0849 
0850     return ret;
0851 }
0852 
0853 static void test_skcipher_speed(const char *algo, int enc, unsigned int secs,
0854                 struct cipher_speed_template *template,
0855                 unsigned int tcount, u8 *keysize, bool async)
0856 {
0857     unsigned int ret, i, j, k, iv_len;
0858     struct tcrypt_result tresult;
0859     const char *key;
0860     char iv[128];
0861     struct skcipher_request *req;
0862     struct crypto_skcipher *tfm;
0863     const char *e;
0864     u32 *b_size;
0865 
0866     if (enc == ENCRYPT)
0867         e = "encryption";
0868     else
0869         e = "decryption";
0870 
0871     init_completion(&tresult.completion);
0872 
0873     tfm = crypto_alloc_skcipher(algo, 0, async ? 0 : CRYPTO_ALG_ASYNC);
0874 
0875     if (IS_ERR(tfm)) {
0876         pr_err("failed to load transform for %s: %ld\n", algo,
0877                PTR_ERR(tfm));
0878         return;
0879     }
0880 
0881     pr_info("\ntesting speed of async %s (%s) %s\n", algo,
0882             get_driver_name(crypto_skcipher, tfm), e);
0883 
0884     req = skcipher_request_alloc(tfm, GFP_KERNEL);
0885     if (!req) {
0886         pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
0887                algo);
0888         goto out;
0889     }
0890 
0891     skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
0892                       tcrypt_complete, &tresult);
0893 
0894     i = 0;
0895     do {
0896         b_size = block_sizes;
0897 
0898         do {
0899             struct scatterlist sg[TVMEMSIZE];
0900 
0901             if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
0902                 pr_err("template (%u) too big for "
0903                        "tvmem (%lu)\n", *keysize + *b_size,
0904                        TVMEMSIZE * PAGE_SIZE);
0905                 goto out_free_req;
0906             }
0907 
0908             pr_info("test %u (%d bit key, %d byte blocks): ", i,
0909                 *keysize * 8, *b_size);
0910 
0911             memset(tvmem[0], 0xff, PAGE_SIZE);
0912 
0913             /* set key, plain text and IV */
0914             key = tvmem[0];
0915             for (j = 0; j < tcount; j++) {
0916                 if (template[j].klen == *keysize) {
0917                     key = template[j].key;
0918                     break;
0919                 }
0920             }
0921 
0922             crypto_skcipher_clear_flags(tfm, ~0);
0923 
0924             ret = crypto_skcipher_setkey(tfm, key, *keysize);
0925             if (ret) {
0926                 pr_err("setkey() failed flags=%x\n",
0927                     crypto_skcipher_get_flags(tfm));
0928                 goto out_free_req;
0929             }
0930 
0931             k = *keysize + *b_size;
0932             sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE));
0933 
0934             if (k > PAGE_SIZE) {
0935                 sg_set_buf(sg, tvmem[0] + *keysize,
0936                    PAGE_SIZE - *keysize);
0937                 k -= PAGE_SIZE;
0938                 j = 1;
0939                 while (k > PAGE_SIZE) {
0940                     sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
0941                     memset(tvmem[j], 0xff, PAGE_SIZE);
0942                     j++;
0943                     k -= PAGE_SIZE;
0944                 }
0945                 sg_set_buf(sg + j, tvmem[j], k);
0946                 memset(tvmem[j], 0xff, k);
0947             } else {
0948                 sg_set_buf(sg, tvmem[0] + *keysize, *b_size);
0949             }
0950 
0951             iv_len = crypto_skcipher_ivsize(tfm);
0952             if (iv_len)
0953                 memset(&iv, 0xff, iv_len);
0954 
0955             skcipher_request_set_crypt(req, sg, sg, *b_size, iv);
0956 
0957             if (secs)
0958                 ret = test_acipher_jiffies(req, enc,
0959                                *b_size, secs);
0960             else
0961                 ret = test_acipher_cycles(req, enc,
0962                               *b_size);
0963 
0964             if (ret) {
0965                 pr_err("%s() failed flags=%x\n", e,
0966                        crypto_skcipher_get_flags(tfm));
0967                 break;
0968             }
0969             b_size++;
0970             i++;
0971         } while (*b_size);
0972         keysize++;
0973     } while (*keysize);
0974 
0975 out_free_req:
0976     skcipher_request_free(req);
0977 out:
0978     crypto_free_skcipher(tfm);
0979 }
0980 
0981 static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
0982                    struct cipher_speed_template *template,
0983                    unsigned int tcount, u8 *keysize)
0984 {
0985     return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
0986                    true);
0987 }
0988 
0989 static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
0990                   struct cipher_speed_template *template,
0991                   unsigned int tcount, u8 *keysize)
0992 {
0993     return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
0994                    false);
0995 }
0996 
0997 static void test_available(void)
0998 {
0999     char **name = check;
1000 
1001     while (*name) {
1002         printk("alg %s ", *name);
1003         printk(crypto_has_alg(*name, 0, 0) ?
1004                "found\n" : "not found\n");
1005         name++;
1006     }
1007 }
1008 
1009 static inline int tcrypt_test(const char *alg)
1010 {
1011     int ret;
1012 
1013     ret = alg_test(alg, alg, 0, 0);
1014     /* non-fips algs return -EINVAL in fips mode */
1015     if (fips_enabled && ret == -EINVAL)
1016         ret = 0;
1017     return ret;
1018 }
1019 
1020 static int do_test(const char *alg, u32 type, u32 mask, int m)
1021 {
1022     int i;
1023     int ret = 0;
1024 
1025     switch (m) {
1026     case 0:
1027         if (alg) {
1028             if (!crypto_has_alg(alg, type,
1029                         mask ?: CRYPTO_ALG_TYPE_MASK))
1030                 ret = -ENOENT;
1031             break;
1032         }
1033 
1034         for (i = 1; i < 200; i++)
1035             ret += do_test(NULL, 0, 0, i);
1036         break;
1037 
1038     case 1:
1039         ret += tcrypt_test("md5");
1040         break;
1041 
1042     case 2:
1043         ret += tcrypt_test("sha1");
1044         break;
1045 
1046     case 3:
1047         ret += tcrypt_test("ecb(des)");
1048         ret += tcrypt_test("cbc(des)");
1049         ret += tcrypt_test("ctr(des)");
1050         break;
1051 
1052     case 4:
1053         ret += tcrypt_test("ecb(des3_ede)");
1054         ret += tcrypt_test("cbc(des3_ede)");
1055         ret += tcrypt_test("ctr(des3_ede)");
1056         break;
1057 
1058     case 5:
1059         ret += tcrypt_test("md4");
1060         break;
1061 
1062     case 6:
1063         ret += tcrypt_test("sha256");
1064         break;
1065 
1066     case 7:
1067         ret += tcrypt_test("ecb(blowfish)");
1068         ret += tcrypt_test("cbc(blowfish)");
1069         ret += tcrypt_test("ctr(blowfish)");
1070         break;
1071 
1072     case 8:
1073         ret += tcrypt_test("ecb(twofish)");
1074         ret += tcrypt_test("cbc(twofish)");
1075         ret += tcrypt_test("ctr(twofish)");
1076         ret += tcrypt_test("lrw(twofish)");
1077         ret += tcrypt_test("xts(twofish)");
1078         break;
1079 
1080     case 9:
1081         ret += tcrypt_test("ecb(serpent)");
1082         ret += tcrypt_test("cbc(serpent)");
1083         ret += tcrypt_test("ctr(serpent)");
1084         ret += tcrypt_test("lrw(serpent)");
1085         ret += tcrypt_test("xts(serpent)");
1086         break;
1087 
1088     case 10:
1089         ret += tcrypt_test("ecb(aes)");
1090         ret += tcrypt_test("cbc(aes)");
1091         ret += tcrypt_test("lrw(aes)");
1092         ret += tcrypt_test("xts(aes)");
1093         ret += tcrypt_test("ctr(aes)");
1094         ret += tcrypt_test("rfc3686(ctr(aes))");
1095         break;
1096 
1097     case 11:
1098         ret += tcrypt_test("sha384");
1099         break;
1100 
1101     case 12:
1102         ret += tcrypt_test("sha512");
1103         break;
1104 
1105     case 13:
1106         ret += tcrypt_test("deflate");
1107         break;
1108 
1109     case 14:
1110         ret += tcrypt_test("ecb(cast5)");
1111         ret += tcrypt_test("cbc(cast5)");
1112         ret += tcrypt_test("ctr(cast5)");
1113         break;
1114 
1115     case 15:
1116         ret += tcrypt_test("ecb(cast6)");
1117         ret += tcrypt_test("cbc(cast6)");
1118         ret += tcrypt_test("ctr(cast6)");
1119         ret += tcrypt_test("lrw(cast6)");
1120         ret += tcrypt_test("xts(cast6)");
1121         break;
1122 
1123     case 16:
1124         ret += tcrypt_test("ecb(arc4)");
1125         break;
1126 
1127     case 17:
1128         ret += tcrypt_test("michael_mic");
1129         break;
1130 
1131     case 18:
1132         ret += tcrypt_test("crc32c");
1133         break;
1134 
1135     case 19:
1136         ret += tcrypt_test("ecb(tea)");
1137         break;
1138 
1139     case 20:
1140         ret += tcrypt_test("ecb(xtea)");
1141         break;
1142 
1143     case 21:
1144         ret += tcrypt_test("ecb(khazad)");
1145         break;
1146 
1147     case 22:
1148         ret += tcrypt_test("wp512");
1149         break;
1150 
1151     case 23:
1152         ret += tcrypt_test("wp384");
1153         break;
1154 
1155     case 24:
1156         ret += tcrypt_test("wp256");
1157         break;
1158 
1159     case 25:
1160         ret += tcrypt_test("ecb(tnepres)");
1161         break;
1162 
1163     case 26:
1164         ret += tcrypt_test("ecb(anubis)");
1165         ret += tcrypt_test("cbc(anubis)");
1166         break;
1167 
1168     case 27:
1169         ret += tcrypt_test("tgr192");
1170         break;
1171 
1172     case 28:
1173         ret += tcrypt_test("tgr160");
1174         break;
1175 
1176     case 29:
1177         ret += tcrypt_test("tgr128");
1178         break;
1179 
1180     case 30:
1181         ret += tcrypt_test("ecb(xeta)");
1182         break;
1183 
1184     case 31:
1185         ret += tcrypt_test("pcbc(fcrypt)");
1186         break;
1187 
1188     case 32:
1189         ret += tcrypt_test("ecb(camellia)");
1190         ret += tcrypt_test("cbc(camellia)");
1191         ret += tcrypt_test("ctr(camellia)");
1192         ret += tcrypt_test("lrw(camellia)");
1193         ret += tcrypt_test("xts(camellia)");
1194         break;
1195 
1196     case 33:
1197         ret += tcrypt_test("sha224");
1198         break;
1199 
1200     case 34:
1201         ret += tcrypt_test("salsa20");
1202         break;
1203 
1204     case 35:
1205         ret += tcrypt_test("gcm(aes)");
1206         break;
1207 
1208     case 36:
1209         ret += tcrypt_test("lzo");
1210         break;
1211 
1212     case 37:
1213         ret += tcrypt_test("ccm(aes)");
1214         break;
1215 
1216     case 38:
1217         ret += tcrypt_test("cts(cbc(aes))");
1218         break;
1219 
1220         case 39:
1221         ret += tcrypt_test("rmd128");
1222         break;
1223 
1224         case 40:
1225         ret += tcrypt_test("rmd160");
1226         break;
1227 
1228     case 41:
1229         ret += tcrypt_test("rmd256");
1230         break;
1231 
1232     case 42:
1233         ret += tcrypt_test("rmd320");
1234         break;
1235 
1236     case 43:
1237         ret += tcrypt_test("ecb(seed)");
1238         break;
1239 
1240     case 44:
1241         ret += tcrypt_test("zlib");
1242         break;
1243 
1244     case 45:
1245         ret += tcrypt_test("rfc4309(ccm(aes))");
1246         break;
1247 
1248     case 46:
1249         ret += tcrypt_test("ghash");
1250         break;
1251 
1252     case 47:
1253         ret += tcrypt_test("crct10dif");
1254         break;
1255 
1256     case 48:
1257         ret += tcrypt_test("sha3-224");
1258         break;
1259 
1260     case 49:
1261         ret += tcrypt_test("sha3-256");
1262         break;
1263 
1264     case 50:
1265         ret += tcrypt_test("sha3-384");
1266         break;
1267 
1268     case 51:
1269         ret += tcrypt_test("sha3-512");
1270         break;
1271 
1272     case 100:
1273         ret += tcrypt_test("hmac(md5)");
1274         break;
1275 
1276     case 101:
1277         ret += tcrypt_test("hmac(sha1)");
1278         break;
1279 
1280     case 102:
1281         ret += tcrypt_test("hmac(sha256)");
1282         break;
1283 
1284     case 103:
1285         ret += tcrypt_test("hmac(sha384)");
1286         break;
1287 
1288     case 104:
1289         ret += tcrypt_test("hmac(sha512)");
1290         break;
1291 
1292     case 105:
1293         ret += tcrypt_test("hmac(sha224)");
1294         break;
1295 
1296     case 106:
1297         ret += tcrypt_test("xcbc(aes)");
1298         break;
1299 
1300     case 107:
1301         ret += tcrypt_test("hmac(rmd128)");
1302         break;
1303 
1304     case 108:
1305         ret += tcrypt_test("hmac(rmd160)");
1306         break;
1307 
1308     case 109:
1309         ret += tcrypt_test("vmac(aes)");
1310         break;
1311 
1312     case 110:
1313         ret += tcrypt_test("hmac(crc32)");
1314         break;
1315 
1316     case 111:
1317         ret += tcrypt_test("hmac(sha3-224)");
1318         break;
1319 
1320     case 112:
1321         ret += tcrypt_test("hmac(sha3-256)");
1322         break;
1323 
1324     case 113:
1325         ret += tcrypt_test("hmac(sha3-384)");
1326         break;
1327 
1328     case 114:
1329         ret += tcrypt_test("hmac(sha3-512)");
1330         break;
1331 
1332     case 150:
1333         ret += tcrypt_test("ansi_cprng");
1334         break;
1335 
1336     case 151:
1337         ret += tcrypt_test("rfc4106(gcm(aes))");
1338         break;
1339 
1340     case 152:
1341         ret += tcrypt_test("rfc4543(gcm(aes))");
1342         break;
1343 
1344     case 153:
1345         ret += tcrypt_test("cmac(aes)");
1346         break;
1347 
1348     case 154:
1349         ret += tcrypt_test("cmac(des3_ede)");
1350         break;
1351 
1352     case 155:
1353         ret += tcrypt_test("authenc(hmac(sha1),cbc(aes))");
1354         break;
1355 
1356     case 156:
1357         ret += tcrypt_test("authenc(hmac(md5),ecb(cipher_null))");
1358         break;
1359 
1360     case 157:
1361         ret += tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))");
1362         break;
1363     case 181:
1364         ret += tcrypt_test("authenc(hmac(sha1),cbc(des))");
1365         break;
1366     case 182:
1367         ret += tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))");
1368         break;
1369     case 183:
1370         ret += tcrypt_test("authenc(hmac(sha224),cbc(des))");
1371         break;
1372     case 184:
1373         ret += tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))");
1374         break;
1375     case 185:
1376         ret += tcrypt_test("authenc(hmac(sha256),cbc(des))");
1377         break;
1378     case 186:
1379         ret += tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))");
1380         break;
1381     case 187:
1382         ret += tcrypt_test("authenc(hmac(sha384),cbc(des))");
1383         break;
1384     case 188:
1385         ret += tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))");
1386         break;
1387     case 189:
1388         ret += tcrypt_test("authenc(hmac(sha512),cbc(des))");
1389         break;
1390     case 190:
1391         ret += tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))");
1392         break;
1393     case 200:
1394         test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1395                 speed_template_16_24_32);
1396         test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1397                 speed_template_16_24_32);
1398         test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1399                 speed_template_16_24_32);
1400         test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1401                 speed_template_16_24_32);
1402         test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1403                 speed_template_32_40_48);
1404         test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1405                 speed_template_32_40_48);
1406         test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1407                 speed_template_32_48_64);
1408         test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1409                 speed_template_32_48_64);
1410         test_cipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
1411                 speed_template_16_24_32);
1412         test_cipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
1413                 speed_template_16_24_32);
1414         test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1415                 speed_template_16_24_32);
1416         test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1417                 speed_template_16_24_32);
1418         break;
1419 
1420     case 201:
1421         test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1422                 des3_speed_template, DES3_SPEED_VECTORS,
1423                 speed_template_24);
1424         test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1425                 des3_speed_template, DES3_SPEED_VECTORS,
1426                 speed_template_24);
1427         test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1428                 des3_speed_template, DES3_SPEED_VECTORS,
1429                 speed_template_24);
1430         test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1431                 des3_speed_template, DES3_SPEED_VECTORS,
1432                 speed_template_24);
1433         test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec,
1434                 des3_speed_template, DES3_SPEED_VECTORS,
1435                 speed_template_24);
1436         test_cipher_speed("ctr(des3_ede)", DECRYPT, sec,
1437                 des3_speed_template, DES3_SPEED_VECTORS,
1438                 speed_template_24);
1439         break;
1440 
1441     case 202:
1442         test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1443                 speed_template_16_24_32);
1444         test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1445                 speed_template_16_24_32);
1446         test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1447                 speed_template_16_24_32);
1448         test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1449                 speed_template_16_24_32);
1450         test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1451                 speed_template_16_24_32);
1452         test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1453                 speed_template_16_24_32);
1454         test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1455                 speed_template_32_40_48);
1456         test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1457                 speed_template_32_40_48);
1458         test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1459                 speed_template_32_48_64);
1460         test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1461                 speed_template_32_48_64);
1462         break;
1463 
1464     case 203:
1465         test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1466                   speed_template_8_32);
1467         test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1468                   speed_template_8_32);
1469         test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1470                   speed_template_8_32);
1471         test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1472                   speed_template_8_32);
1473         test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
1474                   speed_template_8_32);
1475         test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
1476                   speed_template_8_32);
1477         break;
1478 
1479     case 204:
1480         test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1481                   speed_template_8);
1482         test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1483                   speed_template_8);
1484         test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1485                   speed_template_8);
1486         test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1487                   speed_template_8);
1488         break;
1489 
1490     case 205:
1491         test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1492                 speed_template_16_24_32);
1493         test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1494                 speed_template_16_24_32);
1495         test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1496                 speed_template_16_24_32);
1497         test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1498                 speed_template_16_24_32);
1499         test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
1500                 speed_template_16_24_32);
1501         test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
1502                 speed_template_16_24_32);
1503         test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
1504                 speed_template_32_40_48);
1505         test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
1506                 speed_template_32_40_48);
1507         test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
1508                 speed_template_32_48_64);
1509         test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
1510                 speed_template_32_48_64);
1511         break;
1512 
1513     case 206:
1514         test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1515                   speed_template_16_32);
1516         break;
1517 
1518     case 207:
1519         test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1520                   speed_template_16_32);
1521         test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1522                   speed_template_16_32);
1523         test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1524                   speed_template_16_32);
1525         test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1526                   speed_template_16_32);
1527         test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1528                   speed_template_16_32);
1529         test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1530                   speed_template_16_32);
1531         test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1532                   speed_template_32_48);
1533         test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1534                   speed_template_32_48);
1535         test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1536                   speed_template_32_64);
1537         test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1538                   speed_template_32_64);
1539         break;
1540 
1541     case 208:
1542         test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
1543                   speed_template_8);
1544         break;
1545 
1546     case 209:
1547         test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
1548                   speed_template_8_16);
1549         test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
1550                   speed_template_8_16);
1551         test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
1552                   speed_template_8_16);
1553         test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
1554                   speed_template_8_16);
1555         test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
1556                   speed_template_8_16);
1557         test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
1558                   speed_template_8_16);
1559         break;
1560 
1561     case 210:
1562         test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
1563                   speed_template_16_32);
1564         test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
1565                   speed_template_16_32);
1566         test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
1567                   speed_template_16_32);
1568         test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
1569                   speed_template_16_32);
1570         test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
1571                   speed_template_16_32);
1572         test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
1573                   speed_template_16_32);
1574         test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
1575                   speed_template_32_48);
1576         test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
1577                   speed_template_32_48);
1578         test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
1579                   speed_template_32_64);
1580         test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
1581                   speed_template_32_64);
1582         break;
1583 
1584     case 211:
1585         test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec,
1586                 NULL, 0, 16, 16, aead_speed_template_20);
1587         test_aead_speed("gcm(aes)", ENCRYPT, sec,
1588                 NULL, 0, 16, 8, speed_template_16_24_32);
1589         break;
1590 
1591     case 212:
1592         test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec,
1593                 NULL, 0, 16, 16, aead_speed_template_19);
1594         break;
1595 
1596     case 213:
1597         test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, sec,
1598                 NULL, 0, 16, 8, aead_speed_template_36);
1599         break;
1600 
1601     case 214:
1602         test_cipher_speed("chacha20", ENCRYPT, sec, NULL, 0,
1603                   speed_template_32);
1604         break;
1605 
1606 
1607     case 300:
1608         if (alg) {
1609             test_hash_speed(alg, sec, generic_hash_speed_template);
1610             break;
1611         }
1612 
1613         /* fall through */
1614 
1615     case 301:
1616         test_hash_speed("md4", sec, generic_hash_speed_template);
1617         if (mode > 300 && mode < 400) break;
1618 
1619     case 302:
1620         test_hash_speed("md5", sec, generic_hash_speed_template);
1621         if (mode > 300 && mode < 400) break;
1622 
1623     case 303:
1624         test_hash_speed("sha1", sec, generic_hash_speed_template);
1625         if (mode > 300 && mode < 400) break;
1626 
1627     case 304:
1628         test_hash_speed("sha256", sec, generic_hash_speed_template);
1629         if (mode > 300 && mode < 400) break;
1630 
1631     case 305:
1632         test_hash_speed("sha384", sec, generic_hash_speed_template);
1633         if (mode > 300 && mode < 400) break;
1634 
1635     case 306:
1636         test_hash_speed("sha512", sec, generic_hash_speed_template);
1637         if (mode > 300 && mode < 400) break;
1638 
1639     case 307:
1640         test_hash_speed("wp256", sec, generic_hash_speed_template);
1641         if (mode > 300 && mode < 400) break;
1642 
1643     case 308:
1644         test_hash_speed("wp384", sec, generic_hash_speed_template);
1645         if (mode > 300 && mode < 400) break;
1646 
1647     case 309:
1648         test_hash_speed("wp512", sec, generic_hash_speed_template);
1649         if (mode > 300 && mode < 400) break;
1650 
1651     case 310:
1652         test_hash_speed("tgr128", sec, generic_hash_speed_template);
1653         if (mode > 300 && mode < 400) break;
1654 
1655     case 311:
1656         test_hash_speed("tgr160", sec, generic_hash_speed_template);
1657         if (mode > 300 && mode < 400) break;
1658 
1659     case 312:
1660         test_hash_speed("tgr192", sec, generic_hash_speed_template);
1661         if (mode > 300 && mode < 400) break;
1662 
1663     case 313:
1664         test_hash_speed("sha224", sec, generic_hash_speed_template);
1665         if (mode > 300 && mode < 400) break;
1666 
1667     case 314:
1668         test_hash_speed("rmd128", sec, generic_hash_speed_template);
1669         if (mode > 300 && mode < 400) break;
1670 
1671     case 315:
1672         test_hash_speed("rmd160", sec, generic_hash_speed_template);
1673         if (mode > 300 && mode < 400) break;
1674 
1675     case 316:
1676         test_hash_speed("rmd256", sec, generic_hash_speed_template);
1677         if (mode > 300 && mode < 400) break;
1678 
1679     case 317:
1680         test_hash_speed("rmd320", sec, generic_hash_speed_template);
1681         if (mode > 300 && mode < 400) break;
1682 
1683     case 318:
1684         test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1685         if (mode > 300 && mode < 400) break;
1686 
1687     case 319:
1688         test_hash_speed("crc32c", sec, generic_hash_speed_template);
1689         if (mode > 300 && mode < 400) break;
1690 
1691     case 320:
1692         test_hash_speed("crct10dif", sec, generic_hash_speed_template);
1693         if (mode > 300 && mode < 400) break;
1694 
1695     case 321:
1696         test_hash_speed("poly1305", sec, poly1305_speed_template);
1697         if (mode > 300 && mode < 400) break;
1698 
1699     case 322:
1700         test_hash_speed("sha3-224", sec, generic_hash_speed_template);
1701         if (mode > 300 && mode < 400) break;
1702 
1703     case 323:
1704         test_hash_speed("sha3-256", sec, generic_hash_speed_template);
1705         if (mode > 300 && mode < 400) break;
1706 
1707     case 324:
1708         test_hash_speed("sha3-384", sec, generic_hash_speed_template);
1709         if (mode > 300 && mode < 400) break;
1710 
1711     case 325:
1712         test_hash_speed("sha3-512", sec, generic_hash_speed_template);
1713         if (mode > 300 && mode < 400) break;
1714 
1715     case 399:
1716         break;
1717 
1718     case 400:
1719         if (alg) {
1720             test_ahash_speed(alg, sec, generic_hash_speed_template);
1721             break;
1722         }
1723 
1724         /* fall through */
1725 
1726     case 401:
1727         test_ahash_speed("md4", sec, generic_hash_speed_template);
1728         if (mode > 400 && mode < 500) break;
1729 
1730     case 402:
1731         test_ahash_speed("md5", sec, generic_hash_speed_template);
1732         if (mode > 400 && mode < 500) break;
1733 
1734     case 403:
1735         test_ahash_speed("sha1", sec, generic_hash_speed_template);
1736         if (mode > 400 && mode < 500) break;
1737 
1738     case 404:
1739         test_ahash_speed("sha256", sec, generic_hash_speed_template);
1740         if (mode > 400 && mode < 500) break;
1741 
1742     case 405:
1743         test_ahash_speed("sha384", sec, generic_hash_speed_template);
1744         if (mode > 400 && mode < 500) break;
1745 
1746     case 406:
1747         test_ahash_speed("sha512", sec, generic_hash_speed_template);
1748         if (mode > 400 && mode < 500) break;
1749 
1750     case 407:
1751         test_ahash_speed("wp256", sec, generic_hash_speed_template);
1752         if (mode > 400 && mode < 500) break;
1753 
1754     case 408:
1755         test_ahash_speed("wp384", sec, generic_hash_speed_template);
1756         if (mode > 400 && mode < 500) break;
1757 
1758     case 409:
1759         test_ahash_speed("wp512", sec, generic_hash_speed_template);
1760         if (mode > 400 && mode < 500) break;
1761 
1762     case 410:
1763         test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1764         if (mode > 400 && mode < 500) break;
1765 
1766     case 411:
1767         test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1768         if (mode > 400 && mode < 500) break;
1769 
1770     case 412:
1771         test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1772         if (mode > 400 && mode < 500) break;
1773 
1774     case 413:
1775         test_ahash_speed("sha224", sec, generic_hash_speed_template);
1776         if (mode > 400 && mode < 500) break;
1777 
1778     case 414:
1779         test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1780         if (mode > 400 && mode < 500) break;
1781 
1782     case 415:
1783         test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1784         if (mode > 400 && mode < 500) break;
1785 
1786     case 416:
1787         test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1788         if (mode > 400 && mode < 500) break;
1789 
1790     case 417:
1791         test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1792         if (mode > 400 && mode < 500) break;
1793 
1794     case 418:
1795         test_ahash_speed("sha3-224", sec, generic_hash_speed_template);
1796         if (mode > 400 && mode < 500) break;
1797 
1798     case 419:
1799         test_ahash_speed("sha3-256", sec, generic_hash_speed_template);
1800         if (mode > 400 && mode < 500) break;
1801 
1802     case 420:
1803         test_ahash_speed("sha3-384", sec, generic_hash_speed_template);
1804         if (mode > 400 && mode < 500) break;
1805 
1806 
1807     case 421:
1808         test_ahash_speed("sha3-512", sec, generic_hash_speed_template);
1809         if (mode > 400 && mode < 500) break;
1810 
1811     case 422:
1812         test_mb_ahash_speed("sha1", sec, generic_hash_speed_template);
1813         if (mode > 400 && mode < 500) break;
1814 
1815     case 423:
1816         test_mb_ahash_speed("sha256", sec, generic_hash_speed_template);
1817         if (mode > 400 && mode < 500) break;
1818 
1819     case 424:
1820         test_mb_ahash_speed("sha512", sec, generic_hash_speed_template);
1821         if (mode > 400 && mode < 500) break;
1822 
1823     case 499:
1824         break;
1825 
1826     case 500:
1827         test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1828                    speed_template_16_24_32);
1829         test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1830                    speed_template_16_24_32);
1831         test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1832                    speed_template_16_24_32);
1833         test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1834                    speed_template_16_24_32);
1835         test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1836                    speed_template_32_40_48);
1837         test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1838                    speed_template_32_40_48);
1839         test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1840                    speed_template_32_48_64);
1841         test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1842                    speed_template_32_48_64);
1843         test_acipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
1844                    speed_template_16_24_32);
1845         test_acipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
1846                    speed_template_16_24_32);
1847         test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1848                    speed_template_16_24_32);
1849         test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1850                    speed_template_16_24_32);
1851         test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
1852                    speed_template_16_24_32);
1853         test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
1854                    speed_template_16_24_32);
1855         test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
1856                    speed_template_16_24_32);
1857         test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
1858                    speed_template_16_24_32);
1859         test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0,
1860                    speed_template_20_28_36);
1861         test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0,
1862                    speed_template_20_28_36);
1863         break;
1864 
1865     case 501:
1866         test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1867                    des3_speed_template, DES3_SPEED_VECTORS,
1868                    speed_template_24);
1869         test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
1870                    des3_speed_template, DES3_SPEED_VECTORS,
1871                    speed_template_24);
1872         test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1873                    des3_speed_template, DES3_SPEED_VECTORS,
1874                    speed_template_24);
1875         test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
1876                    des3_speed_template, DES3_SPEED_VECTORS,
1877                    speed_template_24);
1878         test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec,
1879                    des3_speed_template, DES3_SPEED_VECTORS,
1880                    speed_template_24);
1881         test_acipher_speed("cfb(des3_ede)", DECRYPT, sec,
1882                    des3_speed_template, DES3_SPEED_VECTORS,
1883                    speed_template_24);
1884         test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec,
1885                    des3_speed_template, DES3_SPEED_VECTORS,
1886                    speed_template_24);
1887         test_acipher_speed("ofb(des3_ede)", DECRYPT, sec,
1888                    des3_speed_template, DES3_SPEED_VECTORS,
1889                    speed_template_24);
1890         break;
1891 
1892     case 502:
1893         test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1894                    speed_template_8);
1895         test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1896                    speed_template_8);
1897         test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1898                    speed_template_8);
1899         test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1900                    speed_template_8);
1901         test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
1902                    speed_template_8);
1903         test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
1904                    speed_template_8);
1905         test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
1906                    speed_template_8);
1907         test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
1908                    speed_template_8);
1909         break;
1910 
1911     case 503:
1912         test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1913                    speed_template_16_32);
1914         test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1915                    speed_template_16_32);
1916         test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1917                    speed_template_16_32);
1918         test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1919                    speed_template_16_32);
1920         test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1921                    speed_template_16_32);
1922         test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1923                    speed_template_16_32);
1924         test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1925                    speed_template_32_48);
1926         test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1927                    speed_template_32_48);
1928         test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1929                    speed_template_32_64);
1930         test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1931                    speed_template_32_64);
1932         break;
1933 
1934     case 504:
1935         test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1936                    speed_template_16_24_32);
1937         test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1938                    speed_template_16_24_32);
1939         test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1940                    speed_template_16_24_32);
1941         test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1942                    speed_template_16_24_32);
1943         test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1944                    speed_template_16_24_32);
1945         test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1946                    speed_template_16_24_32);
1947         test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1948                    speed_template_32_40_48);
1949         test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1950                    speed_template_32_40_48);
1951         test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1952                    speed_template_32_48_64);
1953         test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1954                    speed_template_32_48_64);
1955         break;
1956 
1957     case 505:
1958         test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
1959                    speed_template_8);
1960         break;
1961 
1962     case 506:
1963         test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
1964                    speed_template_8_16);
1965         test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
1966                    speed_template_8_16);
1967         test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
1968                    speed_template_8_16);
1969         test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
1970                    speed_template_8_16);
1971         test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
1972                    speed_template_8_16);
1973         test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
1974                    speed_template_8_16);
1975         break;
1976 
1977     case 507:
1978         test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
1979                    speed_template_16_32);
1980         test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
1981                    speed_template_16_32);
1982         test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
1983                    speed_template_16_32);
1984         test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
1985                    speed_template_16_32);
1986         test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
1987                    speed_template_16_32);
1988         test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
1989                    speed_template_16_32);
1990         test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
1991                    speed_template_32_48);
1992         test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
1993                    speed_template_32_48);
1994         test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
1995                    speed_template_32_64);
1996         test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
1997                    speed_template_32_64);
1998         break;
1999 
2000     case 508:
2001         test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2002                    speed_template_16_32);
2003         test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2004                    speed_template_16_32);
2005         test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2006                    speed_template_16_32);
2007         test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2008                    speed_template_16_32);
2009         test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2010                    speed_template_16_32);
2011         test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2012                    speed_template_16_32);
2013         test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2014                    speed_template_32_48);
2015         test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2016                    speed_template_32_48);
2017         test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2018                    speed_template_32_64);
2019         test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2020                    speed_template_32_64);
2021         break;
2022 
2023     case 509:
2024         test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2025                    speed_template_8_32);
2026         test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2027                    speed_template_8_32);
2028         test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2029                    speed_template_8_32);
2030         test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2031                    speed_template_8_32);
2032         test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2033                    speed_template_8_32);
2034         test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2035                    speed_template_8_32);
2036         break;
2037 
2038     case 1000:
2039         test_available();
2040         break;
2041     }
2042 
2043     return ret;
2044 }
2045 
2046 static int __init tcrypt_mod_init(void)
2047 {
2048     int err = -ENOMEM;
2049     int i;
2050 
2051     for (i = 0; i < TVMEMSIZE; i++) {
2052         tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
2053         if (!tvmem[i])
2054             goto err_free_tv;
2055     }
2056 
2057     err = do_test(alg, type, mask, mode);
2058 
2059     if (err) {
2060         printk(KERN_ERR "tcrypt: one or more tests failed!\n");
2061         goto err_free_tv;
2062     }
2063 
2064     /* We intentionaly return -EAGAIN to prevent keeping the module,
2065      * unless we're running in fips mode. It does all its work from
2066      * init() and doesn't offer any runtime functionality, but in
2067      * the fips case, checking for a successful load is helpful.
2068      * => we don't need it in the memory, do we?
2069      *                                        -- mludvig
2070      */
2071     if (!fips_enabled)
2072         err = -EAGAIN;
2073 
2074 err_free_tv:
2075     for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
2076         free_page((unsigned long)tvmem[i]);
2077 
2078     return err;
2079 }
2080 
2081 /*
2082  * If an init function is provided, an exit function must also be provided
2083  * to allow module unload.
2084  */
2085 static void __exit tcrypt_mod_fini(void) { }
2086 
2087 module_init(tcrypt_mod_init);
2088 module_exit(tcrypt_mod_fini);
2089 
2090 module_param(alg, charp, 0);
2091 module_param(type, uint, 0);
2092 module_param(mask, uint, 0);
2093 module_param(mode, int, 0);
2094 module_param(sec, uint, 0);
2095 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
2096               "(defaults to zero which uses CPU cycles instead)");
2097 
2098 MODULE_LICENSE("GPL");
2099 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2100 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");