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