crypto/tcrypt.c

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