crypto/tcrypt.c

   1 /*
   2  * Quick & dirty crypto testing module.
   3  *
   4  * This will only exist until we have a better testing mechanism
   5  * (e.g. a char device).
   6  *
   7  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
   8  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
   9  * Copyright (c) 2007 Nokia Siemens Networks
  10  *
  11  * Updated RFC4106 AES-GCM testing.
  12  *    Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
  13  *             Adrian Hoban <adrian.hoban@intel.com>
  14  *             Gabriele Paoloni <gabriele.paoloni@intel.com>
  15  *             Tadeusz Struk (tadeusz.struk@intel.com)
  16  *             Copyright (c) 2010, Intel Corporation.
  17  *
  18  * This program is free software; you can redistribute it and/or modify it
  19  * under the terms of the GNU General Public License as published by the Free
  20  * Software Foundation; either version 2 of the License, or (at your option)
  21  * any later version.
  22  *
  23  */
  24
  25 #include <crypto/aead.h>
  26 #include <crypto/hash.h>
  27 #include <crypto/skcipher.h>
  28 #include <linux/err.h>
  29 #include <linux/fips.h>
  30 #include <linux/init.h>
  31 #include <linux/gfp.h>
  32 #include <linux/module.h>
  33 #include <linux/scatterlist.h>
  34 #include <linux/string.h>
  35 #include <linux/moduleparam.h>
  36 #include <linux/jiffies.h>
  37 #include <linux/timex.h>
  38 #include <linux/interrupt.h>
  39 #include "tcrypt.h"
  40
  41 /*
  42  * Need slab memory for testing (size in number of pages).
  43  */
  44 #define TVMEMSIZE       4
  45
  46 /*
  47 * Used by test_cipher_speed()
  48 */
  49 #define ENCRYPT 1
  50 #define DECRYPT 0
  51
  52 #define MAX_DIGEST_SIZE         64
  53
  54 /*
  55  * return a string with the driver name
  56  */
  57 #define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm))
  58
  59 /*
  60  * Used by test_cipher_speed()
  61  */
  62 static unsigned int sec;
  63
  64 static char *alg = NULL;
  65 static u32 type;
  66 static u32 mask;
  67 static int mode;
  68 static char *tvmem[TVMEMSIZE];
  69
  70 static char *check[] = {
  71         "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
  72         "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
  73         "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  74         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
  75         "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
  76         "lzo", "cts", "zlib", "sha3-224", "sha3-256", "sha3-384", "sha3-512",
  77         NULL
  78 };
  79
  80 struct tcrypt_result {
  81         struct completion completion;
  82         int err;
  83 };
  84
  85 static void tcrypt_complete(struct crypto_async_request *req, int err)
  86 {
  87         struct tcrypt_result *res = req->data;
  88
  89         if (err == -EINPROGRESS)
  90                 return;
  91
  92         res->err = err;
  93         complete(&res->completion);
  94 }
  95
  96 static inline int do_one_aead_op(struct aead_request *req, int ret)
  97 {
  98         if (ret == -EINPROGRESS || ret == -EBUSY) {
  99                 struct tcrypt_result *tr = req->base.data;
 100
 101                 ret = wait_for_completion_interruptible(&tr->completion);
 102                 if (!ret)
 103                         ret = tr->err;
 104                 reinit_completion(&tr->completion);
 105         }
 106
 107         return ret;
 108 }
 109
 110 static int test_aead_jiffies(struct aead_request *req, int enc,
 111                                 int blen, int secs)
 112 {
 113         unsigned long start, end;
 114         int bcount;
 115         int ret;
 116
 117         for (start = jiffies, end = start + secs * HZ, bcount = 0;
 118              time_before(jiffies, end); bcount++) {
 119                 if (enc)
 120                         ret = do_one_aead_op(req, crypto_aead_encrypt(req));
 121                 else
 122                         ret = do_one_aead_op(req, crypto_aead_decrypt(req));
 123
 124                 if (ret)
 125                         return ret;
 126         }
 127
 128         printk("%d operations in %d seconds (%ld bytes)\n",
 129                bcount, secs, (long)bcount * blen);
 130         return 0;
 131 }
 132
 133 static int test_aead_cycles(struct aead_request *req, int enc, int blen)
 134 {
 135         unsigned long cycles = 0;
 136         int ret = 0;
 137         int i;
 138
 139         local_irq_disable();
 140
 141         /* Warm-up run. */
 142         for (i = 0; i < 4; i++) {
 143                 if (enc)
 144                         ret = do_one_aead_op(req, crypto_aead_encrypt(req));
 145                 else
 146                         ret = do_one_aead_op(req, crypto_aead_decrypt(req));
 147
 148                 if (ret)
 149                         goto out;
 150         }
 151
 152         /* The real thing. */
 153         for (i = 0; i < 8; i++) {
 154                 cycles_t start, end;
 155
 156                 start = get_cycles();
 157                 if (enc)
 158                         ret = do_one_aead_op(req, crypto_aead_encrypt(req));
 159                 else
 160                         ret = do_one_aead_op(req, crypto_aead_decrypt(req));
 161                 end = get_cycles();
 162
 163                 if (ret)
 164                         goto out;
 165
 166                 cycles += end - start;
 167         }
 168
 169 out:
 170         local_irq_enable();
 171
 172         if (ret == 0)
 173                 printk("1 operation in %lu cycles (%d bytes)\n",
 174                        (cycles + 4) / 8, blen);
 175
 176         return ret;
 177 }
 178
 179 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
 180 static u32 aead_sizes[] = { 16, 64, 256, 512, 1024, 2048, 4096, 8192, 0 };
 181
 182 #define XBUFSIZE 8
 183 #define MAX_IVLEN 32
 184
 185 static int testmgr_alloc_buf(char *buf[XBUFSIZE])
 186 {
 187         int i;
 188
 189         for (i = 0; i < XBUFSIZE; i++) {
 190                 buf[i] = (void *)__get_free_page(GFP_KERNEL);
 191                 if (!buf[i])
 192                         goto err_free_buf;
 193         }
 194
 195         return 0;
 196
 197 err_free_buf:
 198         while (i-- > 0)
 199                 free_page((unsigned long)buf[i]);
 200
 201         return -ENOMEM;
 202 }
 203
 204 static void testmgr_free_buf(char *buf[XBUFSIZE])
 205 {
 206         int i;
 207
 208         for (i = 0; i < XBUFSIZE; i++)
 209                 free_page((unsigned long)buf[i]);
 210 }
 211
 212 static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE],
 213                         unsigned int buflen)
 214 {
 215         int np = (buflen + PAGE_SIZE - 1)/PAGE_SIZE;
 216         int k, rem;
 217
 218         if (np > XBUFSIZE) {
 219                 rem = PAGE_SIZE;
 220                 np = XBUFSIZE;
 221         } else {
 222                 rem = buflen % PAGE_SIZE;
 223         }
 224
 225         sg_init_table(sg, np + 1);
 226         np--;
 227         for (k = 0; k < np; k++)
 228                 sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE);
 229
 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 ? authsize : 0));
 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, *b_size, iv);
 354                         aead_request_set_ad(req, aad_size);
 355
 356                         if (secs)
 357                                 ret = test_aead_jiffies(req, enc, *b_size,
 358                                                         secs);
 359                         else
 360                                 ret = test_aead_cycles(req, enc, *b_size);
 361
 362                         if (ret) {
 363                                 pr_err("%s() failed return code=%d\n", e, ret);
 364                                 break;
 365                         }
 366                         b_size++;
 367                         i++;
 368                 } while (*b_size);
 369                 keysize++;
 370         } while (*keysize);
 371
 372 out:
 373         aead_request_free(req);
 374 out_noreq:
 375         crypto_free_aead(tfm);
 376 out_notfm:
 377         kfree(sg);
 378 out_nosg:
 379         testmgr_free_buf(xoutbuf);
 380 out_nooutbuf:
 381         testmgr_free_buf(axbuf);
 382 out_noaxbuf:
 383         testmgr_free_buf(xbuf);
 384 out_noxbuf:
 385         kfree(iv);
 386         return;
 387 }
 388
 389 static void test_hash_sg_init(struct scatterlist *sg)
 390 {
 391         int i;
 392
 393         sg_init_table(sg, TVMEMSIZE);
 394         for (i = 0; i < TVMEMSIZE; i++) {
 395                 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
 396                 memset(tvmem[i], 0xff, PAGE_SIZE);
 397         }
 398 }
 399
 400 static inline int do_one_ahash_op(struct ahash_request *req, int ret)
 401 {
 402         if (ret == -EINPROGRESS || ret == -EBUSY) {
 403                 struct tcrypt_result *tr = req->base.data;
 404
 405                 wait_for_completion(&tr->completion);
 406                 reinit_completion(&tr->completion);
 407                 ret = tr->err;
 408         }
 409         return ret;
 410 }
 411
 412 struct test_mb_ahash_data {
 413         struct scatterlist sg[TVMEMSIZE];
 414         char result[64];
 415         struct ahash_request *req;
 416         struct tcrypt_result tresult;
 417         char *xbuf[XBUFSIZE];
 418 };
 419
 420 static void test_mb_ahash_speed(const char *algo, unsigned int sec,
 421                                 struct hash_speed *speed)
 422 {
 423         struct test_mb_ahash_data *data;
 424         struct crypto_ahash *tfm;
 425         unsigned long start, end;
 426         unsigned long cycles;
 427         unsigned int i, j, k;
 428         int ret;
 429
 430         data = kzalloc(sizeof(*data) * 8, GFP_KERNEL);
 431         if (!data)
 432                 return;
 433
 434         tfm = crypto_alloc_ahash(algo, 0, 0);
 435         if (IS_ERR(tfm)) {
 436                 pr_err("failed to load transform for %s: %ld\n",
 437                         algo, PTR_ERR(tfm));
 438                 goto free_data;
 439         }
 440
 441         for (i = 0; i < 8; ++i) {
 442                 if (testmgr_alloc_buf(data[i].xbuf))
 443                         goto out;
 444
 445                 init_completion(&data[i].tresult.completion);
 446
 447                 data[i].req = ahash_request_alloc(tfm, GFP_KERNEL);
 448                 if (!data[i].req) {
 449                         pr_err("alg: hash: Failed to allocate request for %s\n",
 450                                algo);
 451                         goto out;
 452                 }
 453
 454                 ahash_request_set_callback(data[i].req, 0,
 455                                            tcrypt_complete, &data[i].tresult);
 456                 test_hash_sg_init(data[i].sg);
 457         }
 458
 459         pr_info("\ntesting speed of multibuffer %s (%s)\n", algo,
 460                 get_driver_name(crypto_ahash, tfm));
 461
 462         for (i = 0; speed[i].blen != 0; i++) {
 463                 /* For some reason this only tests digests. */
 464                 if (speed[i].blen != speed[i].plen)
 465                         continue;
 466
 467                 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
 468                         pr_err("template (%u) too big for tvmem (%lu)\n",
 469                                speed[i].blen, TVMEMSIZE * PAGE_SIZE);
 470                         goto out;
 471                 }
 472
 473                 if (speed[i].klen)
 474                         crypto_ahash_setkey(tfm, tvmem[0], speed[i].klen);
 475
 476                 for (k = 0; k < 8; k++)
 477                         ahash_request_set_crypt(data[k].req, data[k].sg,
 478                                                 data[k].result, speed[i].blen);
 479
 480                 pr_info("test%3u "
 481                         "(%5u byte blocks,%5u bytes per update,%4u updates): ",
 482                         i, speed[i].blen, speed[i].plen,
 483                         speed[i].blen / speed[i].plen);
 484
 485                 start = get_cycles();
 486
 487                 for (k = 0; k < 8; k++) {
 488                         ret = crypto_ahash_digest(data[k].req);
 489                         if (ret == -EINPROGRESS)
 490                                 continue;
 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         ret = alg_test(alg, alg, 0, 0);
1012         /* non-fips algs return -EINVAL in fips mode */
1013         if (fips_enabled && ret == -EINVAL)
1014                 ret = 0;
1015         return ret;
1016 }
1017
1018 static int do_test(const char *alg, u32 type, u32 mask, int m)
1019 {
1020         int i;
1021         int ret = 0;
1022
1023         switch (m) {
1024         case 0:
1025                 if (alg) {
1026                         if (!crypto_has_alg(alg, type,
1027                                             mask ?: CRYPTO_ALG_TYPE_MASK))
1028                                 ret = -ENOENT;
1029                         break;
1030                 }
1031
1032                 for (i = 1; i < 200; i++)
1033                         ret += do_test(NULL, 0, 0, i);
1034                 break;
1035
1036         case 1:
1037                 ret += tcrypt_test("md5");
1038                 break;
1039
1040         case 2:
1041                 ret += tcrypt_test("sha1");
1042                 break;
1043
1044         case 3:
1045                 ret += tcrypt_test("ecb(des)");
1046                 ret += tcrypt_test("cbc(des)");
1047                 ret += tcrypt_test("ctr(des)");
1048                 break;
1049
1050         case 4:
1051                 ret += tcrypt_test("ecb(des3_ede)");
1052                 ret += tcrypt_test("cbc(des3_ede)");
1053                 ret += tcrypt_test("ctr(des3_ede)");
1054                 break;
1055
1056         case 5:
1057                 ret += tcrypt_test("md4");
1058                 break;
1059
1060         case 6:
1061                 ret += tcrypt_test("sha256");
1062                 break;
1063
1064         case 7:
1065                 ret += tcrypt_test("ecb(blowfish)");
1066                 ret += tcrypt_test("cbc(blowfish)");
1067                 ret += tcrypt_test("ctr(blowfish)");
1068                 break;
1069
1070         case 8:
1071                 ret += tcrypt_test("ecb(twofish)");
1072                 ret += tcrypt_test("cbc(twofish)");
1073                 ret += tcrypt_test("ctr(twofish)");
1074                 ret += tcrypt_test("lrw(twofish)");
1075                 ret += tcrypt_test("xts(twofish)");
1076                 break;
1077
1078         case 9:
1079                 ret += tcrypt_test("ecb(serpent)");
1080                 ret += tcrypt_test("cbc(serpent)");
1081                 ret += tcrypt_test("ctr(serpent)");
1082                 ret += tcrypt_test("lrw(serpent)");
1083                 ret += tcrypt_test("xts(serpent)");
1084                 break;
1085
1086         case 10:
1087                 ret += tcrypt_test("ecb(aes)");
1088                 ret += tcrypt_test("cbc(aes)");
1089                 ret += tcrypt_test("lrw(aes)");
1090                 ret += tcrypt_test("xts(aes)");
1091                 ret += tcrypt_test("ctr(aes)");
1092                 ret += tcrypt_test("rfc3686(ctr(aes))");
1093                 break;
1094
1095         case 11:
1096                 ret += tcrypt_test("sha384");
1097                 break;
1098
1099         case 12:
1100                 ret += tcrypt_test("sha512");
1101                 break;
1102
1103         case 13:
1104                 ret += tcrypt_test("deflate");
1105                 break;
1106
1107         case 14:
1108                 ret += tcrypt_test("ecb(cast5)");
1109                 ret += tcrypt_test("cbc(cast5)");
1110                 ret += tcrypt_test("ctr(cast5)");
1111                 break;
1112
1113         case 15:
1114                 ret += tcrypt_test("ecb(cast6)");
1115                 ret += tcrypt_test("cbc(cast6)");
1116                 ret += tcrypt_test("ctr(cast6)");
1117                 ret += tcrypt_test("lrw(cast6)");
1118                 ret += tcrypt_test("xts(cast6)");
1119                 break;
1120
1121         case 16:
1122                 ret += tcrypt_test("ecb(arc4)");
1123                 break;
1124
1125         case 17:
1126                 ret += tcrypt_test("michael_mic");
1127                 break;
1128
1129         case 18:
1130                 ret += tcrypt_test("crc32c");
1131                 break;
1132
1133         case 19:
1134                 ret += tcrypt_test("ecb(tea)");
1135                 break;
1136
1137         case 20:
1138                 ret += tcrypt_test("ecb(xtea)");
1139                 break;
1140
1141         case 21:
1142                 ret += tcrypt_test("ecb(khazad)");
1143                 break;
1144
1145         case 22:
1146                 ret += tcrypt_test("wp512");
1147                 break;
1148
1149         case 23:
1150                 ret += tcrypt_test("wp384");
1151                 break;
1152
1153         case 24:
1154                 ret += tcrypt_test("wp256");
1155                 break;
1156
1157         case 25:
1158                 ret += tcrypt_test("ecb(tnepres)");
1159                 break;
1160
1161         case 26:
1162                 ret += tcrypt_test("ecb(anubis)");
1163                 ret += tcrypt_test("cbc(anubis)");
1164                 break;
1165
1166         case 27:
1167                 ret += tcrypt_test("tgr192");
1168                 break;
1169
1170         case 28:
1171                 ret += tcrypt_test("tgr160");
1172                 break;
1173
1174         case 29:
1175                 ret += tcrypt_test("tgr128");
1176                 break;
1177
1178         case 30:
1179                 ret += tcrypt_test("ecb(xeta)");
1180                 break;
1181
1182         case 31:
1183                 ret += tcrypt_test("pcbc(fcrypt)");
1184                 break;
1185
1186         case 32:
1187                 ret += tcrypt_test("ecb(camellia)");
1188                 ret += tcrypt_test("cbc(camellia)");
1189                 ret += tcrypt_test("ctr(camellia)");
1190                 ret += tcrypt_test("lrw(camellia)");
1191                 ret += tcrypt_test("xts(camellia)");
1192                 break;
1193
1194         case 33:
1195                 ret += tcrypt_test("sha224");
1196                 break;
1197
1198         case 34:
1199                 ret += tcrypt_test("salsa20");
1200                 break;
1201
1202         case 35:
1203                 ret += tcrypt_test("gcm(aes)");
1204                 break;
1205
1206         case 36:
1207                 ret += tcrypt_test("lzo");
1208                 break;
1209
1210         case 37:
1211                 ret += tcrypt_test("ccm(aes)");
1212                 break;
1213
1214         case 38:
1215                 ret += tcrypt_test("cts(cbc(aes))");
1216                 break;
1217
1218         case 39:
1219                 ret += tcrypt_test("rmd128");
1220                 break;
1221
1222         case 40:
1223                 ret += tcrypt_test("rmd160");
1224                 break;
1225
1226         case 41:
1227                 ret += tcrypt_test("rmd256");
1228                 break;
1229
1230         case 42:
1231                 ret += tcrypt_test("rmd320");
1232                 break;
1233
1234         case 43:
1235                 ret += tcrypt_test("ecb(seed)");
1236                 break;
1237
1238         case 44:
1239                 ret += tcrypt_test("zlib");
1240                 break;
1241
1242         case 45:
1243                 ret += tcrypt_test("rfc4309(ccm(aes))");
1244                 break;
1245
1246         case 46:
1247                 ret += tcrypt_test("ghash");
1248                 break;
1249
1250         case 47:
1251                 ret += tcrypt_test("crct10dif");
1252                 break;
1253
1254         case 48:
1255                 ret += tcrypt_test("sha3-224");
1256                 break;
1257
1258         case 49:
1259                 ret += tcrypt_test("sha3-256");
1260                 break;
1261
1262         case 50:
1263                 ret += tcrypt_test("sha3-384");
1264                 break;
1265
1266         case 51:
1267                 ret += tcrypt_test("sha3-512");
1268                 break;
1269
1270         case 100:
1271                 ret += tcrypt_test("hmac(md5)");
1272                 break;
1273
1274         case 101:
1275                 ret += tcrypt_test("hmac(sha1)");
1276                 break;
1277
1278         case 102:
1279                 ret += tcrypt_test("hmac(sha256)");
1280                 break;
1281
1282         case 103:
1283                 ret += tcrypt_test("hmac(sha384)");
1284                 break;
1285
1286         case 104:
1287                 ret += tcrypt_test("hmac(sha512)");
1288                 break;
1289
1290         case 105:
1291                 ret += tcrypt_test("hmac(sha224)");
1292                 break;
1293
1294         case 106:
1295                 ret += tcrypt_test("xcbc(aes)");
1296                 break;
1297
1298         case 107:
1299                 ret += tcrypt_test("hmac(rmd128)");
1300                 break;
1301
1302         case 108:
1303                 ret += tcrypt_test("hmac(rmd160)");
1304                 break;
1305
1306         case 109:
1307                 ret += tcrypt_test("vmac(aes)");
1308                 break;
1309
1310         case 110:
1311                 ret += tcrypt_test("hmac(crc32)");
1312                 break;
1313
1314         case 150:
1315                 ret += tcrypt_test("ansi_cprng");
1316                 break;
1317
1318         case 151:
1319                 ret += tcrypt_test("rfc4106(gcm(aes))");
1320                 break;
1321
1322         case 152:
1323                 ret += tcrypt_test("rfc4543(gcm(aes))");
1324                 break;
1325
1326         case 153:
1327                 ret += tcrypt_test("cmac(aes)");
1328                 break;
1329
1330         case 154:
1331                 ret += tcrypt_test("cmac(des3_ede)");
1332                 break;
1333
1334         case 155:
1335                 ret += tcrypt_test("authenc(hmac(sha1),cbc(aes))");
1336                 break;
1337
1338         case 156:
1339                 ret += tcrypt_test("authenc(hmac(md5),ecb(cipher_null))");
1340                 break;
1341
1342         case 157:
1343                 ret += tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))");
1344                 break;
1345         case 181:
1346                 ret += tcrypt_test("authenc(hmac(sha1),cbc(des))");
1347                 break;
1348         case 182:
1349                 ret += tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))");
1350                 break;
1351         case 183:
1352                 ret += tcrypt_test("authenc(hmac(sha224),cbc(des))");
1353                 break;
1354         case 184:
1355                 ret += tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))");
1356                 break;
1357         case 185:
1358                 ret += tcrypt_test("authenc(hmac(sha256),cbc(des))");
1359                 break;
1360         case 186:
1361                 ret += tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))");
1362                 break;
1363         case 187:
1364                 ret += tcrypt_test("authenc(hmac(sha384),cbc(des))");
1365                 break;
1366         case 188:
1367                 ret += tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))");
1368                 break;
1369         case 189:
1370                 ret += tcrypt_test("authenc(hmac(sha512),cbc(des))");
1371                 break;
1372         case 190:
1373                 ret += tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))");
1374                 break;
1375         case 200:
1376                 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1377                                 speed_template_16_24_32);
1378                 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1379                                 speed_template_16_24_32);
1380                 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1381                                 speed_template_16_24_32);
1382                 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1383                                 speed_template_16_24_32);
1384                 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1385                                 speed_template_32_40_48);
1386                 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1387                                 speed_template_32_40_48);
1388                 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1389                                 speed_template_32_48_64);
1390                 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1391                                 speed_template_32_48_64);
1392                 test_cipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
1393                                 speed_template_16_24_32);
1394                 test_cipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
1395                                 speed_template_16_24_32);
1396                 test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1397                                 speed_template_16_24_32);
1398                 test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1399                                 speed_template_16_24_32);
1400                 break;
1401
1402         case 201:
1403                 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1404                                 des3_speed_template, DES3_SPEED_VECTORS,
1405                                 speed_template_24);
1406                 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1407                                 des3_speed_template, DES3_SPEED_VECTORS,
1408                                 speed_template_24);
1409                 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1410                                 des3_speed_template, DES3_SPEED_VECTORS,
1411                                 speed_template_24);
1412                 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1413                                 des3_speed_template, DES3_SPEED_VECTORS,
1414                                 speed_template_24);
1415                 test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec,
1416                                 des3_speed_template, DES3_SPEED_VECTORS,
1417                                 speed_template_24);
1418                 test_cipher_speed("ctr(des3_ede)", DECRYPT, sec,
1419                                 des3_speed_template, DES3_SPEED_VECTORS,
1420                                 speed_template_24);
1421                 break;
1422
1423         case 202:
1424                 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1425                                 speed_template_16_24_32);
1426                 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1427                                 speed_template_16_24_32);
1428                 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1429                                 speed_template_16_24_32);
1430                 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1431                                 speed_template_16_24_32);
1432                 test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1433                                 speed_template_16_24_32);
1434                 test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1435                                 speed_template_16_24_32);
1436                 test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1437                                 speed_template_32_40_48);
1438                 test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1439                                 speed_template_32_40_48);
1440                 test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1441                                 speed_template_32_48_64);
1442                 test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1443                                 speed_template_32_48_64);
1444                 break;
1445
1446         case 203:
1447                 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1448                                   speed_template_8_32);
1449                 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1450                                   speed_template_8_32);
1451                 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1452                                   speed_template_8_32);
1453                 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1454                                   speed_template_8_32);
1455                 test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
1456                                   speed_template_8_32);
1457                 test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
1458                                   speed_template_8_32);
1459                 break;
1460
1461         case 204:
1462                 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1463                                   speed_template_8);
1464                 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1465                                   speed_template_8);
1466                 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1467                                   speed_template_8);
1468                 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1469                                   speed_template_8);
1470                 break;
1471
1472         case 205:
1473                 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1474                                 speed_template_16_24_32);
1475                 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1476                                 speed_template_16_24_32);
1477                 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1478                                 speed_template_16_24_32);
1479                 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1480                                 speed_template_16_24_32);
1481                 test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
1482                                 speed_template_16_24_32);
1483                 test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
1484                                 speed_template_16_24_32);
1485                 test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
1486                                 speed_template_32_40_48);
1487                 test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
1488                                 speed_template_32_40_48);
1489                 test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
1490                                 speed_template_32_48_64);
1491                 test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
1492                                 speed_template_32_48_64);
1493                 break;
1494
1495         case 206:
1496                 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1497                                   speed_template_16_32);
1498                 break;
1499
1500         case 207:
1501                 test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1502                                   speed_template_16_32);
1503                 test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1504                                   speed_template_16_32);
1505                 test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1506                                   speed_template_16_32);
1507                 test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1508                                   speed_template_16_32);
1509                 test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1510                                   speed_template_16_32);
1511                 test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1512                                   speed_template_16_32);
1513                 test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1514                                   speed_template_32_48);
1515                 test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1516                                   speed_template_32_48);
1517                 test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1518                                   speed_template_32_64);
1519                 test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1520                                   speed_template_32_64);
1521                 break;
1522
1523         case 208:
1524                 test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
1525                                   speed_template_8);
1526                 break;
1527
1528         case 209:
1529                 test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
1530                                   speed_template_8_16);
1531                 test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
1532                                   speed_template_8_16);
1533                 test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
1534                                   speed_template_8_16);
1535                 test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
1536                                   speed_template_8_16);
1537                 test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
1538                                   speed_template_8_16);
1539                 test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
1540                                   speed_template_8_16);
1541                 break;
1542
1543         case 210:
1544                 test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
1545                                   speed_template_16_32);
1546                 test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
1547                                   speed_template_16_32);
1548                 test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
1549                                   speed_template_16_32);
1550                 test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
1551                                   speed_template_16_32);
1552                 test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
1553                                   speed_template_16_32);
1554                 test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
1555                                   speed_template_16_32);
1556                 test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
1557                                   speed_template_32_48);
1558                 test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
1559                                   speed_template_32_48);
1560                 test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
1561                                   speed_template_32_64);
1562                 test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
1563                                   speed_template_32_64);
1564                 break;
1565
1566         case 211:
1567                 test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec,
1568                                 NULL, 0, 16, 16, aead_speed_template_20);
1569                 test_aead_speed("gcm(aes)", ENCRYPT, sec,
1570                                 NULL, 0, 16, 8, speed_template_16_24_32);
1571                 break;
1572
1573         case 212:
1574                 test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec,
1575                                 NULL, 0, 16, 16, aead_speed_template_19);
1576                 break;
1577
1578         case 213:
1579                 test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, sec,
1580                                 NULL, 0, 16, 8, aead_speed_template_36);
1581                 break;
1582
1583         case 214:
1584                 test_cipher_speed("chacha20", ENCRYPT, sec, NULL, 0,
1585                                   speed_template_32);
1586                 break;
1587
1588
1589         case 300:
1590                 if (alg) {
1591                         test_hash_speed(alg, sec, generic_hash_speed_template);
1592                         break;
1593                 }
1594
1595                 /* fall through */
1596
1597         case 301:
1598                 test_hash_speed("md4", sec, generic_hash_speed_template);
1599                 if (mode > 300 && mode < 400) break;
1600
1601         case 302:
1602                 test_hash_speed("md5", sec, generic_hash_speed_template);
1603                 if (mode > 300 && mode < 400) break;
1604
1605         case 303:
1606                 test_hash_speed("sha1", sec, generic_hash_speed_template);
1607                 if (mode > 300 && mode < 400) break;
1608
1609         case 304:
1610                 test_hash_speed("sha256", sec, generic_hash_speed_template);
1611                 if (mode > 300 && mode < 400) break;
1612
1613         case 305:
1614                 test_hash_speed("sha384", sec, generic_hash_speed_template);
1615                 if (mode > 300 && mode < 400) break;
1616
1617         case 306:
1618                 test_hash_speed("sha512", sec, generic_hash_speed_template);
1619                 if (mode > 300 && mode < 400) break;
1620
1621         case 307:
1622                 test_hash_speed("wp256", sec, generic_hash_speed_template);
1623                 if (mode > 300 && mode < 400) break;
1624
1625         case 308:
1626                 test_hash_speed("wp384", sec, generic_hash_speed_template);
1627                 if (mode > 300 && mode < 400) break;
1628
1629         case 309:
1630                 test_hash_speed("wp512", sec, generic_hash_speed_template);
1631                 if (mode > 300 && mode < 400) break;
1632
1633         case 310:
1634                 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1635                 if (mode > 300 && mode < 400) break;
1636
1637         case 311:
1638                 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1639                 if (mode > 300 && mode < 400) break;
1640
1641         case 312:
1642                 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1643                 if (mode > 300 && mode < 400) break;
1644
1645         case 313:
1646                 test_hash_speed("sha224", sec, generic_hash_speed_template);
1647                 if (mode > 300 && mode < 400) break;
1648
1649         case 314:
1650                 test_hash_speed("rmd128", sec, generic_hash_speed_template);
1651                 if (mode > 300 && mode < 400) break;
1652
1653         case 315:
1654                 test_hash_speed("rmd160", sec, generic_hash_speed_template);
1655                 if (mode > 300 && mode < 400) break;
1656
1657         case 316:
1658                 test_hash_speed("rmd256", sec, generic_hash_speed_template);
1659                 if (mode > 300 && mode < 400) break;
1660
1661         case 317:
1662                 test_hash_speed("rmd320", sec, generic_hash_speed_template);
1663                 if (mode > 300 && mode < 400) break;
1664
1665         case 318:
1666                 test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1667                 if (mode > 300 && mode < 400) break;
1668
1669         case 319:
1670                 test_hash_speed("crc32c", sec, generic_hash_speed_template);
1671                 if (mode > 300 && mode < 400) break;
1672
1673         case 320:
1674                 test_hash_speed("crct10dif", sec, generic_hash_speed_template);
1675                 if (mode > 300 && mode < 400) break;
1676
1677         case 321:
1678                 test_hash_speed("poly1305", sec, poly1305_speed_template);
1679                 if (mode > 300 && mode < 400) break;
1680
1681         case 322:
1682                 test_hash_speed("sha3-224", sec, generic_hash_speed_template);
1683                 if (mode > 300 && mode < 400) break;
1684
1685         case 323:
1686                 test_hash_speed("sha3-256", sec, generic_hash_speed_template);
1687                 if (mode > 300 && mode < 400) break;
1688
1689         case 324:
1690                 test_hash_speed("sha3-384", sec, generic_hash_speed_template);
1691                 if (mode > 300 && mode < 400) break;
1692
1693         case 325:
1694                 test_hash_speed("sha3-512", sec, generic_hash_speed_template);
1695                 if (mode > 300 && mode < 400) break;
1696
1697         case 399:
1698                 break;
1699
1700         case 400:
1701                 if (alg) {
1702                         test_ahash_speed(alg, sec, generic_hash_speed_template);
1703                         break;
1704                 }
1705
1706                 /* fall through */
1707
1708         case 401:
1709                 test_ahash_speed("md4", sec, generic_hash_speed_template);
1710                 if (mode > 400 && mode < 500) break;
1711
1712         case 402:
1713                 test_ahash_speed("md5", sec, generic_hash_speed_template);
1714                 if (mode > 400 && mode < 500) break;
1715
1716         case 403:
1717                 test_ahash_speed("sha1", sec, generic_hash_speed_template);
1718                 if (mode > 400 && mode < 500) break;
1719
1720         case 404:
1721                 test_ahash_speed("sha256", sec, generic_hash_speed_template);
1722                 if (mode > 400 && mode < 500) break;
1723
1724         case 405:
1725                 test_ahash_speed("sha384", sec, generic_hash_speed_template);
1726                 if (mode > 400 && mode < 500) break;
1727
1728         case 406:
1729                 test_ahash_speed("sha512", sec, generic_hash_speed_template);
1730                 if (mode > 400 && mode < 500) break;
1731
1732         case 407:
1733                 test_ahash_speed("wp256", sec, generic_hash_speed_template);
1734                 if (mode > 400 && mode < 500) break;
1735
1736         case 408:
1737                 test_ahash_speed("wp384", sec, generic_hash_speed_template);
1738                 if (mode > 400 && mode < 500) break;
1739
1740         case 409:
1741                 test_ahash_speed("wp512", sec, generic_hash_speed_template);
1742                 if (mode > 400 && mode < 500) break;
1743
1744         case 410:
1745                 test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1746                 if (mode > 400 && mode < 500) break;
1747
1748         case 411:
1749                 test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1750                 if (mode > 400 && mode < 500) break;
1751
1752         case 412:
1753                 test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1754                 if (mode > 400 && mode < 500) break;
1755
1756         case 413:
1757                 test_ahash_speed("sha224", sec, generic_hash_speed_template);
1758                 if (mode > 400 && mode < 500) break;
1759
1760         case 414:
1761                 test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1762                 if (mode > 400 && mode < 500) break;
1763
1764         case 415:
1765                 test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1766                 if (mode > 400 && mode < 500) break;
1767
1768         case 416:
1769                 test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1770                 if (mode > 400 && mode < 500) break;
1771
1772         case 417:
1773                 test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1774                 if (mode > 400 && mode < 500) break;
1775
1776         case 418:
1777                 test_ahash_speed("sha3-224", sec, generic_hash_speed_template);
1778                 if (mode > 400 && mode < 500) break;
1779
1780         case 419:
1781                 test_ahash_speed("sha3-256", sec, generic_hash_speed_template);
1782                 if (mode > 400 && mode < 500) break;
1783
1784         case 420:
1785                 test_ahash_speed("sha3-384", sec, generic_hash_speed_template);
1786                 if (mode > 400 && mode < 500) break;
1787
1788
1789         case 421:
1790                 test_ahash_speed("sha3-512", sec, generic_hash_speed_template);
1791                 if (mode > 400 && mode < 500) break;
1792
1793         case 422:
1794                 test_mb_ahash_speed("sha1", sec, generic_hash_speed_template);
1795                 if (mode > 400 && mode < 500) break;
1796
1797         case 423:
1798                 test_mb_ahash_speed("sha256", sec, generic_hash_speed_template);
1799                 if (mode > 400 && mode < 500) break;
1800
1801         case 424:
1802                 test_mb_ahash_speed("sha512", sec, generic_hash_speed_template);
1803                 if (mode > 400 && mode < 500) break;
1804
1805         case 499:
1806                 break;
1807
1808         case 500:
1809                 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1810                                    speed_template_16_24_32);
1811                 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1812                                    speed_template_16_24_32);
1813                 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1814                                    speed_template_16_24_32);
1815                 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1816                                    speed_template_16_24_32);
1817                 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1818                                    speed_template_32_40_48);
1819                 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1820                                    speed_template_32_40_48);
1821                 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1822                                    speed_template_32_48_64);
1823                 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1824                                    speed_template_32_48_64);
1825                 test_acipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
1826                                    speed_template_16_24_32);
1827                 test_acipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
1828                                    speed_template_16_24_32);
1829                 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1830                                    speed_template_16_24_32);
1831                 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1832                                    speed_template_16_24_32);
1833                 test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
1834                                    speed_template_16_24_32);
1835                 test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
1836                                    speed_template_16_24_32);
1837                 test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
1838                                    speed_template_16_24_32);
1839                 test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
1840                                    speed_template_16_24_32);
1841                 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0,
1842                                    speed_template_20_28_36);
1843                 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0,
1844                                    speed_template_20_28_36);
1845                 break;
1846
1847         case 501:
1848                 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1849                                    des3_speed_template, DES3_SPEED_VECTORS,
1850                                    speed_template_24);
1851                 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
1852                                    des3_speed_template, DES3_SPEED_VECTORS,
1853                                    speed_template_24);
1854                 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1855                                    des3_speed_template, DES3_SPEED_VECTORS,
1856                                    speed_template_24);
1857                 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
1858                                    des3_speed_template, DES3_SPEED_VECTORS,
1859                                    speed_template_24);
1860                 test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec,
1861                                    des3_speed_template, DES3_SPEED_VECTORS,
1862                                    speed_template_24);
1863                 test_acipher_speed("cfb(des3_ede)", DECRYPT, sec,
1864                                    des3_speed_template, DES3_SPEED_VECTORS,
1865                                    speed_template_24);
1866                 test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec,
1867                                    des3_speed_template, DES3_SPEED_VECTORS,
1868                                    speed_template_24);
1869                 test_acipher_speed("ofb(des3_ede)", DECRYPT, sec,
1870                                    des3_speed_template, DES3_SPEED_VECTORS,
1871                                    speed_template_24);
1872                 break;
1873
1874         case 502:
1875                 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1876                                    speed_template_8);
1877                 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1878                                    speed_template_8);
1879                 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1880                                    speed_template_8);
1881                 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1882                                    speed_template_8);
1883                 test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
1884                                    speed_template_8);
1885                 test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
1886                                    speed_template_8);
1887                 test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
1888                                    speed_template_8);
1889                 test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
1890                                    speed_template_8);
1891                 break;
1892
1893         case 503:
1894                 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1895                                    speed_template_16_32);
1896                 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1897                                    speed_template_16_32);
1898                 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1899                                    speed_template_16_32);
1900                 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1901                                    speed_template_16_32);
1902                 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1903                                    speed_template_16_32);
1904                 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1905                                    speed_template_16_32);
1906                 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1907                                    speed_template_32_48);
1908                 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1909                                    speed_template_32_48);
1910                 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1911                                    speed_template_32_64);
1912                 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1913                                    speed_template_32_64);
1914                 break;
1915
1916         case 504:
1917                 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1918                                    speed_template_16_24_32);
1919                 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1920                                    speed_template_16_24_32);
1921                 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1922                                    speed_template_16_24_32);
1923                 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1924                                    speed_template_16_24_32);
1925                 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1926                                    speed_template_16_24_32);
1927                 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1928                                    speed_template_16_24_32);
1929                 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1930                                    speed_template_32_40_48);
1931                 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1932                                    speed_template_32_40_48);
1933                 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1934                                    speed_template_32_48_64);
1935                 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1936                                    speed_template_32_48_64);
1937                 break;
1938
1939         case 505:
1940                 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
1941                                    speed_template_8);
1942                 break;
1943
1944         case 506:
1945                 test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
1946                                    speed_template_8_16);
1947                 test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
1948                                    speed_template_8_16);
1949                 test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
1950                                    speed_template_8_16);
1951                 test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
1952                                    speed_template_8_16);
1953                 test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
1954                                    speed_template_8_16);
1955                 test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
1956                                    speed_template_8_16);
1957                 break;
1958
1959         case 507:
1960                 test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
1961                                    speed_template_16_32);
1962                 test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
1963                                    speed_template_16_32);
1964                 test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
1965                                    speed_template_16_32);
1966                 test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
1967                                    speed_template_16_32);
1968                 test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
1969                                    speed_template_16_32);
1970                 test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
1971                                    speed_template_16_32);
1972                 test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
1973                                    speed_template_32_48);
1974                 test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
1975                                    speed_template_32_48);
1976                 test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
1977                                    speed_template_32_64);
1978                 test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
1979                                    speed_template_32_64);
1980                 break;
1981
1982         case 508:
1983                 test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1984                                    speed_template_16_32);
1985                 test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1986                                    speed_template_16_32);
1987                 test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1988                                    speed_template_16_32);
1989                 test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1990                                    speed_template_16_32);
1991                 test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
1992                                    speed_template_16_32);
1993                 test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
1994                                    speed_template_16_32);
1995                 test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
1996                                    speed_template_32_48);
1997                 test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
1998                                    speed_template_32_48);
1999                 test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2000                                    speed_template_32_64);
2001                 test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2002                                    speed_template_32_64);
2003                 break;
2004
2005         case 509:
2006                 test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2007                                    speed_template_8_32);
2008                 test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2009                                    speed_template_8_32);
2010                 test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2011                                    speed_template_8_32);
2012                 test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2013                                    speed_template_8_32);
2014                 test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2015                                    speed_template_8_32);
2016                 test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2017                                    speed_template_8_32);
2018                 break;
2019
2020         case 1000:
2021                 test_available();
2022                 break;
2023         }
2024
2025         return ret;
2026 }
2027
2028 static int __init tcrypt_mod_init(void)
2029 {
2030         int err = -ENOMEM;
2031         int i;
2032
2033         for (i = 0; i < TVMEMSIZE; i++) {
2034                 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
2035                 if (!tvmem[i])
2036                         goto err_free_tv;
2037         }
2038
2039         err = do_test(alg, type, mask, mode);
2040
2041         if (err) {
2042                 printk(KERN_ERR "tcrypt: one or more tests failed!\n");
2043                 goto err_free_tv;
2044         }
2045
2046         /* We intentionaly return -EAGAIN to prevent keeping the module,
2047          * unless we're running in fips mode. It does all its work from
2048          * init() and doesn't offer any runtime functionality, but in
2049          * the fips case, checking for a successful load is helpful.
2050          * => we don't need it in the memory, do we?
2051          *                                        -- mludvig
2052          */
2053         if (!fips_enabled)
2054                 err = -EAGAIN;
2055
2056 err_free_tv:
2057         for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
2058                 free_page((unsigned long)tvmem[i]);
2059
2060         return err;
2061 }
2062
2063 /*
2064  * If an init function is provided, an exit function must also be provided
2065  * to allow module unload.
2066  */
2067 static void __exit tcrypt_mod_fini(void) { }
2068
2069 module_init(tcrypt_mod_init);
2070 module_exit(tcrypt_mod_fini);
2071
2072 module_param(alg, charp, 0);
2073 module_param(type, uint, 0);
2074 module_param(mask, uint, 0);
2075 module_param(mode, int, 0);
2076 module_param(sec, uint, 0);
2077 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
2078                       "(defaults to zero which uses CPU cycles instead)");
2079
2080 MODULE_LICENSE("GPL");
2081 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2082 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");