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