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