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         if (rem)
 225                 np--;
 226         for (k = 0; k < np; k++)
 227                 sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE);
 228
 229         if (rem)
 230                 sg_set_buf(&sg[k + 1], xbuf[k], rem);
 231 }
 232
 233 static void test_aead_speed(const char *algo, int enc, unsigned int secs,
 234                             struct aead_speed_template *template,
 235                             unsigned int tcount, u8 authsize,
 236                             unsigned int aad_size, u8 *keysize)
 237 {
 238         unsigned int i, j;
 239         struct crypto_aead *tfm;
 240         int ret = -ENOMEM;
 241         const char *key;
 242         struct aead_request *req;
 243         struct scatterlist *sg;
 244         struct scatterlist *sgout;
 245         const char *e;
 246         void *assoc;
 247         char *iv;
 248         char *xbuf[XBUFSIZE];
 249         char *xoutbuf[XBUFSIZE];
 250         char *axbuf[XBUFSIZE];
 251         unsigned int *b_size;
 252         unsigned int iv_len;
 253         struct tcrypt_result result;
 254
 255         iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
 256         if (!iv)
 257                 return;
 258
 259         if (aad_size >= PAGE_SIZE) {
 260                 pr_err("associate data length (%u) too big\n", aad_size);
 261                 goto out_noxbuf;
 262         }
 263
 264         if (enc == ENCRYPT)
 265                 e = "encryption";
 266         else
 267                 e = "decryption";
 268
 269         if (testmgr_alloc_buf(xbuf))
 270                 goto out_noxbuf;
 271         if (testmgr_alloc_buf(axbuf))
 272                 goto out_noaxbuf;
 273         if (testmgr_alloc_buf(xoutbuf))
 274                 goto out_nooutbuf;
 275
 276         sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL);
 277         if (!sg)
 278                 goto out_nosg;
 279         sgout = &sg[9];
 280
 281         tfm = crypto_alloc_aead(algo, 0, 0);
 282
 283         if (IS_ERR(tfm)) {
 284                 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo,
 285                        PTR_ERR(tfm));
 286                 goto out_notfm;
 287         }
 288
 289         init_completion(&result.completion);
 290         printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
 291                         get_driver_name(crypto_aead, tfm), e);
 292
 293         req = aead_request_alloc(tfm, GFP_KERNEL);
 294         if (!req) {
 295                 pr_err("alg: aead: Failed to allocate request for %s\n",
 296                        algo);
 297                 goto out_noreq;
 298         }
 299
 300         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 301                                   tcrypt_complete, &result);
 302
 303         i = 0;
 304         do {
 305                 b_size = aead_sizes;
 306                 do {
 307                         assoc = axbuf[0];
 308                         memset(assoc, 0xff, aad_size);
 309
 310                         if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
 311                                 pr_err("template (%u) too big for tvmem (%lu)\n",
 312                                        *keysize + *b_size,
 313                                         TVMEMSIZE * PAGE_SIZE);
 314                                 goto out;
 315                         }
 316
 317                         key = tvmem[0];
 318                         for (j = 0; j < tcount; j++) {
 319                                 if (template[j].klen == *keysize) {
 320                                         key = template[j].key;
 321                                         break;
 322                                 }
 323                         }
 324                         ret = crypto_aead_setkey(tfm, key, *keysize);
 325                         ret = crypto_aead_setauthsize(tfm, authsize);
 326
 327                         iv_len = crypto_aead_ivsize(tfm);
 328                         if (iv_len)
 329                                 memset(iv, 0xff, iv_len);
 330
 331                         crypto_aead_clear_flags(tfm, ~0);
 332                         printk(KERN_INFO "test %u (%d bit key, %d byte blocks): ",
 333                                         i, *keysize * 8, *b_size);
 334
 335
 336                         memset(tvmem[0], 0xff, PAGE_SIZE);
 337
 338                         if (ret) {
 339                                 pr_err("setkey() failed flags=%x\n",
 340                                                 crypto_aead_get_flags(tfm));
 341                                 goto out;
 342                         }
 343
 344                         sg_init_aead(sg, xbuf,
 345                                     *b_size + (enc ? 0 : authsize));
 346
 347                         sg_init_aead(sgout, xoutbuf,
 348                                     *b_size + (enc ? authsize : 0));
 349
 350                         sg_set_buf(&sg[0], assoc, aad_size);
 351                         sg_set_buf(&sgout[0], assoc, aad_size);
 352
 353                         aead_request_set_crypt(req, sg, sgout,
 354                                                *b_size + (enc ? 0 : authsize),
 355                                                iv);
 356                         aead_request_set_ad(req, aad_size);
 357
 358                         if (secs)
 359                                 ret = test_aead_jiffies(req, enc, *b_size,
 360                                                         secs);
 361                         else
 362                                 ret = test_aead_cycles(req, enc, *b_size);
 363
 364                         if (ret) {
 365                                 pr_err("%s() failed return code=%d\n", e, ret);
 366                                 break;
 367                         }
 368                         b_size++;
 369                         i++;
 370                 } while (*b_size);
 371                 keysize++;
 372         } while (*keysize);
 373
 374 out:
 375         aead_request_free(req);
 376 out_noreq:
 377         crypto_free_aead(tfm);
 378 out_notfm:
 379         kfree(sg);
 380 out_nosg:
 381         testmgr_free_buf(xoutbuf);
 382 out_nooutbuf:
 383         testmgr_free_buf(axbuf);
 384 out_noaxbuf:
 385         testmgr_free_buf(xbuf);
 386 out_noxbuf:
 387         kfree(iv);
 388         return;
 389 }
 390
 391 static void test_hash_sg_init(struct scatterlist *sg)
 392 {
 393         int i;
 394
 395         sg_init_table(sg, TVMEMSIZE);
 396         for (i = 0; i < TVMEMSIZE; i++) {
 397                 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
 398                 memset(tvmem[i], 0xff, PAGE_SIZE);
 399         }
 400 }
 401
 402 static inline int do_one_ahash_op(struct ahash_request *req, int ret)
 403 {
 404         if (ret == -EINPROGRESS || ret == -EBUSY) {
 405                 struct tcrypt_result *tr = req->base.data;
 406
 407                 wait_for_completion(&tr->completion);
 408                 reinit_completion(&tr->completion);
 409                 ret = tr->err;
 410         }
 411         return ret;
 412 }
 413
 414 struct test_mb_ahash_data {
 415         struct scatterlist sg[TVMEMSIZE];
 416         char result[64];
 417         struct ahash_request *req;
 418         struct tcrypt_result tresult;
 419         char *xbuf[XBUFSIZE];
 420 };
 421
 422 static void test_mb_ahash_speed(const char *algo, unsigned int sec,
 423                                 struct hash_speed *speed)
 424 {
 425         struct test_mb_ahash_data *data;
 426         struct crypto_ahash *tfm;
 427         unsigned long start, end;
 428         unsigned long cycles;
 429         unsigned int i, j, k;
 430         int ret;
 431
 432         data = kzalloc(sizeof(*data) * 8, GFP_KERNEL);
 433         if (!data)
 434                 return;
 435
 436         tfm = crypto_alloc_ahash(algo, 0, 0);
 437         if (IS_ERR(tfm)) {
 438                 pr_err("failed to load transform for %s: %ld\n",
 439                         algo, PTR_ERR(tfm));
 440                 goto free_data;
 441         }
 442
 443         for (i = 0; i < 8; ++i) {
 444                 if (testmgr_alloc_buf(data[i].xbuf))
 445                         goto out;
 446
 447                 init_completion(&data[i].tresult.completion);
 448
 449                 data[i].req = ahash_request_alloc(tfm, GFP_KERNEL);
 450                 if (!data[i].req) {
 451                         pr_err("alg: hash: Failed to allocate request for %s\n",
 452                                algo);
 453                         goto out;
 454                 }
 455
 456                 ahash_request_set_callback(data[i].req, 0,
 457                                            tcrypt_complete, &data[i].tresult);
 458                 test_hash_sg_init(data[i].sg);
 459         }
 460
 461         pr_info("\ntesting speed of multibuffer %s (%s)\n", algo,
 462                 get_driver_name(crypto_ahash, tfm));
 463
 464         for (i = 0; speed[i].blen != 0; i++) {
 465                 /* For some reason this only tests digests. */
 466                 if (speed[i].blen != speed[i].plen)
 467                         continue;
 468
 469                 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
 470                         pr_err("template (%u) too big for tvmem (%lu)\n",
 471                                speed[i].blen, TVMEMSIZE * PAGE_SIZE);
 472                         goto out;
 473                 }
 474
 475                 if (speed[i].klen)
 476                         crypto_ahash_setkey(tfm, tvmem[0], speed[i].klen);
 477
 478                 for (k = 0; k < 8; k++)
 479                         ahash_request_set_crypt(data[k].req, data[k].sg,
 480                                                 data[k].result, speed[i].blen);
 481
 482                 pr_info("test%3u "
 483                         "(%5u byte blocks,%5u bytes per update,%4u updates): ",
 484                         i, speed[i].blen, speed[i].plen,
 485                         speed[i].blen / speed[i].plen);
 486
 487                 start = get_cycles();
 488
 489                 for (k = 0; k < 8; k++) {
 490                         ret = crypto_ahash_digest(data[k].req);
 491                         if (ret == -EINPROGRESS) {
 492                                 ret = 0;
 493                                 continue;
 494                         }
 495
 496                         if (ret)
 497                                 break;
 498
 499                         complete(&data[k].tresult.completion);
 500                         data[k].tresult.err = 0;
 501                 }
 502
 503                 for (j = 0; j < k; j++) {
 504                         struct tcrypt_result *tr = &data[j].tresult;
 505
 506                         wait_for_completion(&tr->completion);
 507                         if (tr->err)
 508                                 ret = tr->err;
 509                 }
 510
 511                 end = get_cycles();
 512                 cycles = end - start;
 513                 pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
 514                         cycles, cycles / (8 * speed[i].blen));
 515
 516                 if (ret) {
 517                         pr_err("At least one hashing failed ret=%d\n", ret);
 518                         break;
 519                 }
 520         }
 521
 522 out:
 523         for (k = 0; k < 8; ++k)
 524                 ahash_request_free(data[k].req);
 525
 526         for (k = 0; k < 8; ++k)
 527                 testmgr_free_buf(data[k].xbuf);
 528
 529         crypto_free_ahash(tfm);
 530
 531 free_data:
 532         kfree(data);
 533 }
 534
 535 static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
 536                                      char *out, int secs)
 537 {
 538         unsigned long start, end;
 539         int bcount;
 540         int ret;
 541
 542         for (start = jiffies, end = start + secs * HZ, bcount = 0;
 543              time_before(jiffies, end); bcount++) {
 544                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
 545                 if (ret)
 546                         return ret;
 547         }
 548
 549         printk("%6u opers/sec, %9lu bytes/sec\n",
 550                bcount / secs, ((long)bcount * blen) / secs);
 551
 552         return 0;
 553 }
 554
 555 static int test_ahash_jiffies(struct ahash_request *req, int blen,
 556                               int plen, char *out, int secs)
 557 {
 558         unsigned long start, end;
 559         int bcount, pcount;
 560         int ret;
 561
 562         if (plen == blen)
 563                 return test_ahash_jiffies_digest(req, blen, out, secs);
 564
 565         for (start = jiffies, end = start + secs * HZ, bcount = 0;
 566              time_before(jiffies, end); bcount++) {
 567                 ret = do_one_ahash_op(req, crypto_ahash_init(req));
 568                 if (ret)
 569                         return ret;
 570                 for (pcount = 0; pcount < blen; pcount += plen) {
 571                         ret = do_one_ahash_op(req, crypto_ahash_update(req));
 572                         if (ret)
 573                                 return ret;
 574                 }
 575                 /* we assume there is enough space in 'out' for the result */
 576                 ret = do_one_ahash_op(req, crypto_ahash_final(req));
 577                 if (ret)
 578                         return ret;
 579         }
 580
 581         pr_cont("%6u opers/sec, %9lu bytes/sec\n",
 582                 bcount / secs, ((long)bcount * blen) / secs);
 583
 584         return 0;
 585 }
 586
 587 static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
 588                                     char *out)
 589 {
 590         unsigned long cycles = 0;
 591         int ret, i;
 592
 593         /* Warm-up run. */
 594         for (i = 0; i < 4; i++) {
 595                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
 596                 if (ret)
 597                         goto out;
 598         }
 599
 600         /* The real thing. */
 601         for (i = 0; i < 8; i++) {
 602                 cycles_t start, end;
 603
 604                 start = get_cycles();
 605
 606                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
 607                 if (ret)
 608                         goto out;
 609
 610                 end = get_cycles();
 611
 612                 cycles += end - start;
 613         }
 614
 615 out:
 616         if (ret)
 617                 return ret;
 618
 619         pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
 620                 cycles / 8, cycles / (8 * blen));
 621
 622         return 0;
 623 }
 624
 625 static int test_ahash_cycles(struct ahash_request *req, int blen,
 626                              int plen, char *out)
 627 {
 628         unsigned long cycles = 0;
 629         int i, pcount, ret;
 630
 631         if (plen == blen)
 632                 return test_ahash_cycles_digest(req, blen, out);
 633
 634         /* Warm-up run. */
 635         for (i = 0; i < 4; i++) {
 636                 ret = do_one_ahash_op(req, crypto_ahash_init(req));
 637                 if (ret)
 638                         goto out;
 639                 for (pcount = 0; pcount < blen; pcount += plen) {
 640                         ret = do_one_ahash_op(req, crypto_ahash_update(req));
 641                         if (ret)
 642                                 goto out;
 643                 }
 644                 ret = do_one_ahash_op(req, crypto_ahash_final(req));
 645                 if (ret)
 646                         goto out;
 647         }
 648
 649         /* The real thing. */
 650         for (i = 0; i < 8; i++) {
 651                 cycles_t start, end;
 652
 653                 start = get_cycles();
 654
 655                 ret = do_one_ahash_op(req, crypto_ahash_init(req));
 656                 if (ret)
 657                         goto out;
 658                 for (pcount = 0; pcount < blen; pcount += plen) {
 659                         ret = do_one_ahash_op(req, crypto_ahash_update(req));
 660                         if (ret)
 661                                 goto out;
 662                 }
 663                 ret = do_one_ahash_op(req, crypto_ahash_final(req));
 664                 if (ret)
 665                         goto out;
 666
 667                 end = get_cycles();
 668
 669                 cycles += end - start;
 670         }
 671
 672 out:
 673         if (ret)
 674                 return ret;
 675
 676         pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
 677                 cycles / 8, cycles / (8 * blen));
 678
 679         return 0;
 680 }
 681
 682 static void test_ahash_speed_common(const char *algo, unsigned int secs,
 683                                     struct hash_speed *speed, unsigned mask)
 684 {
 685         struct scatterlist sg[TVMEMSIZE];
 686         struct tcrypt_result tresult;
 687         struct ahash_request *req;
 688         struct crypto_ahash *tfm;
 689         char *output;
 690         int i, ret;
 691
 692         tfm = crypto_alloc_ahash(algo, 0, mask);
 693         if (IS_ERR(tfm)) {
 694                 pr_err("failed to load transform for %s: %ld\n",
 695                        algo, PTR_ERR(tfm));
 696                 return;
 697         }
 698
 699         printk(KERN_INFO "\ntesting speed of async %s (%s)\n", algo,
 700                         get_driver_name(crypto_ahash, tfm));
 701
 702         if (crypto_ahash_digestsize(tfm) > MAX_DIGEST_SIZE) {
 703                 pr_err("digestsize(%u) > %d\n", crypto_ahash_digestsize(tfm),
 704                        MAX_DIGEST_SIZE);
 705                 goto out;
 706         }
 707
 708         test_hash_sg_init(sg);
 709         req = ahash_request_alloc(tfm, GFP_KERNEL);
 710         if (!req) {
 711                 pr_err("ahash request allocation failure\n");
 712                 goto out;
 713         }
 714
 715         init_completion(&tresult.completion);
 716         ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 717                                    tcrypt_complete, &tresult);
 718
 719         output = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
 720         if (!output)
 721                 goto out_nomem;
 722
 723         for (i = 0; speed[i].blen != 0; i++) {
 724                 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
 725                         pr_err("template (%u) too big for tvmem (%lu)\n",
 726                                speed[i].blen, TVMEMSIZE * PAGE_SIZE);
 727                         break;
 728                 }
 729
 730                 if (speed[i].klen)
 731                         crypto_ahash_setkey(tfm, tvmem[0], speed[i].klen);
 732
 733                 pr_info("test%3u "
 734                         "(%5u byte blocks,%5u bytes per update,%4u updates): ",
 735                         i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
 736
 737                 ahash_request_set_crypt(req, sg, output, speed[i].plen);
 738
 739                 if (secs)
 740                         ret = test_ahash_jiffies(req, speed[i].blen,
 741                                                  speed[i].plen, output, secs);
 742                 else
 743                         ret = test_ahash_cycles(req, speed[i].blen,
 744                                                 speed[i].plen, output);
 745
 746                 if (ret) {
 747                         pr_err("hashing failed ret=%d\n", ret);
 748                         break;
 749                 }
 750         }
 751
 752         kfree(output);
 753
 754 out_nomem:
 755         ahash_request_free(req);
 756
 757 out:
 758         crypto_free_ahash(tfm);
 759 }
 760
 761 static void test_ahash_speed(const char *algo, unsigned int secs,
 762                              struct hash_speed *speed)
 763 {
 764         return test_ahash_speed_common(algo, secs, speed, 0);
 765 }
 766
 767 static void test_hash_speed(const char *algo, unsigned int secs,
 768                             struct hash_speed *speed)
 769 {
 770         return test_ahash_speed_common(algo, secs, speed, CRYPTO_ALG_ASYNC);
 771 }
 772
 773 static inline int do_one_acipher_op(struct skcipher_request *req, int ret)
 774 {
 775         if (ret == -EINPROGRESS || ret == -EBUSY) {
 776                 struct tcrypt_result *tr = req->base.data;
 777
 778                 wait_for_completion(&tr->completion);
 779                 reinit_completion(&tr->completion);
 780                 ret = tr->err;
 781         }
 782
 783         return ret;
 784 }
 785
 786 static int test_acipher_jiffies(struct skcipher_request *req, int enc,
 787                                 int blen, int secs)
 788 {
 789         unsigned long start, end;
 790         int bcount;
 791         int ret;
 792
 793         for (start = jiffies, end = start + secs * HZ, bcount = 0;
 794              time_before(jiffies, end); bcount++) {
 795                 if (enc)
 796                         ret = do_one_acipher_op(req,
 797                                                 crypto_skcipher_encrypt(req));
 798                 else
 799                         ret = do_one_acipher_op(req,
 800                                                 crypto_skcipher_decrypt(req));
 801
 802                 if (ret)
 803                         return ret;
 804         }
 805
 806         pr_cont("%d operations in %d seconds (%ld bytes)\n",
 807                 bcount, secs, (long)bcount * blen);
 808         return 0;
 809 }
 810
 811 static int test_acipher_cycles(struct skcipher_request *req, int enc,
 812                                int blen)
 813 {
 814         unsigned long cycles = 0;
 815         int ret = 0;
 816         int i;
 817
 818         /* Warm-up run. */
 819         for (i = 0; i < 4; i++) {
 820                 if (enc)
 821                         ret = do_one_acipher_op(req,
 822                                                 crypto_skcipher_encrypt(req));
 823                 else
 824                         ret = do_one_acipher_op(req,
 825                                                 crypto_skcipher_decrypt(req));
 826
 827                 if (ret)
 828                         goto out;
 829         }
 830
 831         /* The real thing. */
 832         for (i = 0; i < 8; i++) {
 833                 cycles_t start, end;
 834
 835                 start = get_cycles();
 836                 if (enc)
 837                         ret = do_one_acipher_op(req,
 838                                                 crypto_skcipher_encrypt(req));
 839                 else
 840                         ret = do_one_acipher_op(req,
 841                                                 crypto_skcipher_decrypt(req));
 842                 end = get_cycles();
 843
 844                 if (ret)
 845                         goto out;
 846
 847                 cycles += end - start;
 848         }
 849
 850 out:
 851         if (ret == 0)
 852                 pr_cont("1 operation in %lu cycles (%d bytes)\n",
 853                         (cycles + 4) / 8, blen);
 854
 855         return ret;
 856 }
 857
 858 static void test_skcipher_speed(const char *algo, int enc, unsigned int secs,
 859                                 struct cipher_speed_template *template,
 860                                 unsigned int tcount, u8 *keysize, bool async)
 861 {
 862         unsigned int ret, i, j, k, iv_len;
 863         struct tcrypt_result tresult;
 864         const char *key;
 865         char iv[128];
 866         struct skcipher_request *req;
 867         struct crypto_skcipher *tfm;
 868         const char *e;
 869         u32 *b_size;
 870
 871         if (enc == ENCRYPT)
 872                 e = "encryption";
 873         else
 874                 e = "decryption";
 875
 876         init_completion(&tresult.completion);
 877
 878         tfm = crypto_alloc_skcipher(algo, 0, async ? 0 : CRYPTO_ALG_ASYNC);
 879
 880         if (IS_ERR(tfm)) {
 881                 pr_err("failed to load transform for %s: %ld\n", algo,
 882                        PTR_ERR(tfm));
 883                 return;
 884         }
 885
 886         pr_info("\ntesting speed of async %s (%s) %s\n", algo,
 887                         get_driver_name(crypto_skcipher, tfm), e);
 888
 889         req = skcipher_request_alloc(tfm, GFP_KERNEL);
 890         if (!req) {
 891                 pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
 892                        algo);
 893                 goto out;
 894         }
 895
 896         skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 897                                       tcrypt_complete, &tresult);
 898
 899         i = 0;
 900         do {
 901                 b_size = block_sizes;
 902
 903                 do {
 904                         struct scatterlist sg[TVMEMSIZE];
 905
 906                         if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
 907                                 pr_err("template (%u) too big for "
 908                                        "tvmem (%lu)\n", *keysize + *b_size,
 909                                        TVMEMSIZE * PAGE_SIZE);
 910                                 goto out_free_req;
 911                         }
 912
 913                         pr_info("test %u (%d bit key, %d byte blocks): ", i,
 914                                 *keysize * 8, *b_size);
 915
 916                         memset(tvmem[0], 0xff, PAGE_SIZE);
 917
 918                         /* set key, plain text and IV */
 919                         key = tvmem[0];
 920                         for (j = 0; j < tcount; j++) {
 921                                 if (template[j].klen == *keysize) {
 922                                         key = template[j].key;
 923                                         break;
 924                                 }
 925                         }
 926
 927                         crypto_skcipher_clear_flags(tfm, ~0);
 928
 929                         ret = crypto_skcipher_setkey(tfm, key, *keysize);
 930                         if (ret) {
 931                                 pr_err("setkey() failed flags=%x\n",
 932                                         crypto_skcipher_get_flags(tfm));
 933                                 goto out_free_req;
 934                         }
 935
 936                         k = *keysize + *b_size;
 937                         sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE));
 938
 939                         if (k > PAGE_SIZE) {
 940                                 sg_set_buf(sg, tvmem[0] + *keysize,
 941                                    PAGE_SIZE - *keysize);
 942                                 k -= PAGE_SIZE;
 943                                 j = 1;
 944                                 while (k > PAGE_SIZE) {
 945                                         sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
 946                                         memset(tvmem[j], 0xff, PAGE_SIZE);
 947                                         j++;
 948                                         k -= PAGE_SIZE;
 949                                 }
 950                                 sg_set_buf(sg + j, tvmem[j], k);
 951                                 memset(tvmem[j], 0xff, k);
 952                         } else {
 953                                 sg_set_buf(sg, tvmem[0] + *keysize, *b_size);
 954                         }
 955
 956                         iv_len = crypto_skcipher_ivsize(tfm);
 957                         if (iv_len)
 958                                 memset(&iv, 0xff, iv_len);
 959
 960                         skcipher_request_set_crypt(req, sg, sg, *b_size, iv);
 961
 962                         if (secs)
 963                                 ret = test_acipher_jiffies(req, enc,
 964                                                            *b_size, secs);
 965                         else
 966                                 ret = test_acipher_cycles(req, enc,
 967                                                           *b_size);
 968
 969                         if (ret) {
 970                                 pr_err("%s() failed flags=%x\n", e,
 971                                        crypto_skcipher_get_flags(tfm));
 972                                 break;
 973                         }
 974                         b_size++;
 975                         i++;
 976                 } while (*b_size);
 977                 keysize++;
 978         } while (*keysize);
 979
 980 out_free_req:
 981         skcipher_request_free(req);
 982 out:
 983         crypto_free_skcipher(tfm);
 984 }
 985
 986 static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
 987                                struct cipher_speed_template *template,
 988                                unsigned int tcount, u8 *keysize)
 989 {
 990         return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
 991                                    true);
 992 }
 993
 994 static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
 995                               struct cipher_speed_template *template,
 996                               unsigned int tcount, u8 *keysize)
 997 {
 998         return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
 999                                    false);
1000 }
1001
1002 static void test_available(void)
1003 {
1004         char **name = check;
1005
1006         while (*name) {
1007                 printk("alg %s ", *name);
1008                 printk(crypto_has_alg(*name, 0, 0) ?
1009                        "found\n" : "not found\n");
1010                 name++;
1011         }
1012 }
1013
1014 static inline int tcrypt_test(const char *alg)
1015 {
1016         int ret;
1017
1018         pr_debug("testing %s\n", alg);
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_64);
1415                 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1416                                 speed_template_32_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_64);
1848                 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1849                                    speed_template_32_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         } else {
2070                 pr_debug("all tests passed\n");
2071         }
2072
2073         /* We intentionaly return -EAGAIN to prevent keeping the module,
2074          * unless we're running in fips mode. It does all its work from
2075          * init() and doesn't offer any runtime functionality, but in
2076          * the fips case, checking for a successful load is helpful.
2077          * => we don't need it in the memory, do we?
2078          *                                        -- mludvig
2079          */
2080         if (!fips_enabled)
2081                 err = -EAGAIN;
2082
2083 err_free_tv:
2084         for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
2085                 free_page((unsigned long)tvmem[i]);
2086
2087         return err;
2088 }
2089
2090 /*
2091  * If an init function is provided, an exit function must also be provided
2092  * to allow module unload.
2093  */
2094 static void __exit tcrypt_mod_fini(void) { }
2095
2096 module_init(tcrypt_mod_init);
2097 module_exit(tcrypt_mod_fini);
2098
2099 module_param(alg, charp, 0);
2100 module_param(type, uint, 0);
2101 module_param(mask, uint, 0);
2102 module_param(mode, int, 0);
2103 module_param(sec, uint, 0);
2104 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
2105                       "(defaults to zero which uses CPU cycles instead)");
2106
2107 MODULE_LICENSE("GPL");
2108 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2109 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");