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