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