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