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