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/hash.h>
  26#include <linux/err.h>
  27#include <linux/init.h>
  28#include <linux/gfp.h>
  29#include <linux/module.h>
  30#include <linux/scatterlist.h>
  31#include <linux/string.h>
  32#include <linux/moduleparam.h>
  33#include <linux/jiffies.h>
  34#include <linux/timex.h>
  35#include <linux/interrupt.h>
  36#include "tcrypt.h"
  37#include "internal.h"
  38
  39/*
  40 * Need slab memory for testing (size in number of pages).
  41 */
  42#define TVMEMSIZE       4
  43
  44/*
  45* Used by test_cipher_speed()
  46*/
  47#define ENCRYPT 1
  48#define DECRYPT 0
  49
  50/*
  51 * Used by test_cipher_speed()
  52 */
  53static unsigned int sec;
  54
  55static char *alg = NULL;
  56static u32 type;
  57static u32 mask;
  58static int mode;
  59static char *tvmem[TVMEMSIZE];
  60
  61static char *check[] = {
  62        "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
  63        "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
  64        "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  65        "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
  66        "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
  67        "lzo", "cts", "zlib", NULL
  68};
  69
  70static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
  71                               struct scatterlist *sg, int blen, int sec)
  72{
  73        unsigned long start, end;
  74        int bcount;
  75        int ret;
  76
  77        for (start = jiffies, end = start + sec * HZ, bcount = 0;
  78             time_before(jiffies, end); bcount++) {
  79                if (enc)
  80                        ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
  81                else
  82                        ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
  83
  84                if (ret)
  85                        return ret;
  86        }
  87
  88        printk("%d operations in %d seconds (%ld bytes)\n",
  89               bcount, sec, (long)bcount * blen);
  90        return 0;
  91}
  92
  93static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
  94                              struct scatterlist *sg, int blen)
  95{
  96        unsigned long cycles = 0;
  97        int ret = 0;
  98        int i;
  99
 100        local_bh_disable();
 101        local_irq_disable();
 102
 103        /* Warm-up run. */
 104        for (i = 0; i < 4; i++) {
 105                if (enc)
 106                        ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 107                else
 108                        ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 109
 110                if (ret)
 111                        goto out;
 112        }
 113
 114        /* The real thing. */
 115        for (i = 0; i < 8; i++) {
 116                cycles_t start, end;
 117
 118                start = get_cycles();
 119                if (enc)
 120                        ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 121                else
 122                        ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 123                end = get_cycles();
 124
 125                if (ret)
 126                        goto out;
 127
 128                cycles += end - start;
 129        }
 130
 131out:
 132        local_irq_enable();
 133        local_bh_enable();
 134
 135        if (ret == 0)
 136                printk("1 operation in %lu cycles (%d bytes)\n",
 137                       (cycles + 4) / 8, blen);
 138
 139        return ret;
 140}
 141
 142static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
 143
 144static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
 145                              struct cipher_speed_template *template,
 146                              unsigned int tcount, u8 *keysize)
 147{
 148        unsigned int ret, i, j, iv_len;
 149        const char *key;
 150        char iv[128];
 151        struct crypto_blkcipher *tfm;
 152        struct blkcipher_desc desc;
 153        const char *e;
 154        u32 *b_size;
 155
 156        if (enc == ENCRYPT)
 157                e = "encryption";
 158        else
 159                e = "decryption";
 160
 161        printk("\ntesting speed of %s %s\n", algo, e);
 162
 163        tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
 164
 165        if (IS_ERR(tfm)) {
 166                printk("failed to load transform for %s: %ld\n", algo,
 167                       PTR_ERR(tfm));
 168                return;
 169        }
 170        desc.tfm = tfm;
 171        desc.flags = 0;
 172
 173        i = 0;
 174        do {
 175
 176                b_size = block_sizes;
 177                do {
 178                        struct scatterlist sg[TVMEMSIZE];
 179
 180                        if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
 181                                printk("template (%u) too big for "
 182                                       "tvmem (%lu)\n", *keysize + *b_size,
 183                                       TVMEMSIZE * PAGE_SIZE);
 184                                goto out;
 185                        }
 186
 187                        printk("test %u (%d bit key, %d byte blocks): ", i,
 188                                        *keysize * 8, *b_size);
 189
 190                        memset(tvmem[0], 0xff, PAGE_SIZE);
 191
 192                        /* set key, plain text and IV */
 193                        key = tvmem[0];
 194                        for (j = 0; j < tcount; j++) {
 195                                if (template[j].klen == *keysize) {
 196                                        key = template[j].key;
 197                                        break;
 198                                }
 199                        }
 200
 201                        ret = crypto_blkcipher_setkey(tfm, key, *keysize);
 202                        if (ret) {
 203                                printk("setkey() failed flags=%x\n",
 204                                                crypto_blkcipher_get_flags(tfm));
 205                                goto out;
 206                        }
 207
 208                        sg_init_table(sg, TVMEMSIZE);
 209                        sg_set_buf(sg, tvmem[0] + *keysize,
 210                                   PAGE_SIZE - *keysize);
 211                        for (j = 1; j < TVMEMSIZE; j++) {
 212                                sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
 213                                memset (tvmem[j], 0xff, PAGE_SIZE);
 214                        }
 215
 216                        iv_len = crypto_blkcipher_ivsize(tfm);
 217                        if (iv_len) {
 218                                memset(&iv, 0xff, iv_len);
 219                                crypto_blkcipher_set_iv(tfm, iv, iv_len);
 220                        }
 221
 222                        if (sec)
 223                                ret = test_cipher_jiffies(&desc, enc, sg,
 224                                                          *b_size, sec);
 225                        else
 226                                ret = test_cipher_cycles(&desc, enc, sg,
 227                                                         *b_size);
 228
 229                        if (ret) {
 230                                printk("%s() failed flags=%x\n", e, desc.flags);
 231                                break;
 232                        }
 233                        b_size++;
 234                        i++;
 235                } while (*b_size);
 236                keysize++;
 237        } while (*keysize);
 238
 239out:
 240        crypto_free_blkcipher(tfm);
 241}
 242
 243static int test_hash_jiffies_digest(struct hash_desc *desc,
 244                                    struct scatterlist *sg, int blen,
 245                                    char *out, int sec)
 246{
 247        unsigned long start, end;
 248        int bcount;
 249        int ret;
 250
 251        for (start = jiffies, end = start + sec * HZ, bcount = 0;
 252             time_before(jiffies, end); bcount++) {
 253                ret = crypto_hash_digest(desc, sg, blen, out);
 254                if (ret)
 255                        return ret;
 256        }
 257
 258        printk("%6u opers/sec, %9lu bytes/sec\n",
 259               bcount / sec, ((long)bcount * blen) / sec);
 260
 261        return 0;
 262}
 263
 264static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
 265                             int blen, int plen, char *out, int sec)
 266{
 267        unsigned long start, end;
 268        int bcount, pcount;
 269        int ret;
 270
 271        if (plen == blen)
 272                return test_hash_jiffies_digest(desc, sg, blen, out, sec);
 273
 274        for (start = jiffies, end = start + sec * HZ, bcount = 0;
 275             time_before(jiffies, end); bcount++) {
 276                ret = crypto_hash_init(desc);
 277                if (ret)
 278                        return ret;
 279                for (pcount = 0; pcount < blen; pcount += plen) {
 280                        ret = crypto_hash_update(desc, sg, plen);
 281                        if (ret)
 282                                return ret;
 283                }
 284                /* we assume there is enough space in 'out' for the result */
 285                ret = crypto_hash_final(desc, out);
 286                if (ret)
 287                        return ret;
 288        }
 289
 290        printk("%6u opers/sec, %9lu bytes/sec\n",
 291               bcount / sec, ((long)bcount * blen) / sec);
 292
 293        return 0;
 294}
 295
 296static int test_hash_cycles_digest(struct hash_desc *desc,
 297                                   struct scatterlist *sg, int blen, char *out)
 298{
 299        unsigned long cycles = 0;
 300        int i;
 301        int ret;
 302
 303        local_bh_disable();
 304        local_irq_disable();
 305
 306        /* Warm-up run. */
 307        for (i = 0; i < 4; i++) {
 308                ret = crypto_hash_digest(desc, sg, blen, out);
 309                if (ret)
 310                        goto out;
 311        }
 312
 313        /* The real thing. */
 314        for (i = 0; i < 8; i++) {
 315                cycles_t start, end;
 316
 317                start = get_cycles();
 318
 319                ret = crypto_hash_digest(desc, sg, blen, out);
 320                if (ret)
 321                        goto out;
 322
 323                end = get_cycles();
 324
 325                cycles += end - start;
 326        }
 327
 328out:
 329        local_irq_enable();
 330        local_bh_enable();
 331
 332        if (ret)
 333                return ret;
 334
 335        printk("%6lu cycles/operation, %4lu cycles/byte\n",
 336               cycles / 8, cycles / (8 * blen));
 337
 338        return 0;
 339}
 340
 341static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
 342                            int blen, int plen, char *out)
 343{
 344        unsigned long cycles = 0;
 345        int i, pcount;
 346        int ret;
 347
 348        if (plen == blen)
 349                return test_hash_cycles_digest(desc, sg, blen, out);
 350
 351        local_bh_disable();
 352        local_irq_disable();
 353
 354        /* Warm-up run. */
 355        for (i = 0; i < 4; i++) {
 356                ret = crypto_hash_init(desc);
 357                if (ret)
 358                        goto out;
 359                for (pcount = 0; pcount < blen; pcount += plen) {
 360                        ret = crypto_hash_update(desc, sg, plen);
 361                        if (ret)
 362                                goto out;
 363                }
 364                ret = crypto_hash_final(desc, out);
 365                if (ret)
 366                        goto out;
 367        }
 368
 369        /* The real thing. */
 370        for (i = 0; i < 8; i++) {
 371                cycles_t start, end;
 372
 373                start = get_cycles();
 374
 375                ret = crypto_hash_init(desc);
 376                if (ret)
 377                        goto out;
 378                for (pcount = 0; pcount < blen; pcount += plen) {
 379                        ret = crypto_hash_update(desc, sg, plen);
 380                        if (ret)
 381                                goto out;
 382                }
 383                ret = crypto_hash_final(desc, out);
 384                if (ret)
 385                        goto out;
 386
 387                end = get_cycles();
 388
 389                cycles += end - start;
 390        }
 391
 392out:
 393        local_irq_enable();
 394        local_bh_enable();
 395
 396        if (ret)
 397                return ret;
 398
 399        printk("%6lu cycles/operation, %4lu cycles/byte\n",
 400               cycles / 8, cycles / (8 * blen));
 401
 402        return 0;
 403}
 404
 405static void test_hash_sg_init(struct scatterlist *sg)
 406{
 407        int i;
 408
 409        sg_init_table(sg, TVMEMSIZE);
 410        for (i = 0; i < TVMEMSIZE; i++) {
 411                sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
 412                memset(tvmem[i], 0xff, PAGE_SIZE);
 413        }
 414}
 415
 416static void test_hash_speed(const char *algo, unsigned int sec,
 417                            struct hash_speed *speed)
 418{
 419        struct scatterlist sg[TVMEMSIZE];
 420        struct crypto_hash *tfm;
 421        struct hash_desc desc;
 422        static char output[1024];
 423        int i;
 424        int ret;
 425
 426        printk(KERN_INFO "\ntesting speed of %s\n", algo);
 427
 428        tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
 429
 430        if (IS_ERR(tfm)) {
 431                printk(KERN_ERR "failed to load transform for %s: %ld\n", algo,
 432                       PTR_ERR(tfm));
 433                return;
 434        }
 435
 436        desc.tfm = tfm;
 437        desc.flags = 0;
 438
 439        if (crypto_hash_digestsize(tfm) > sizeof(output)) {
 440                printk(KERN_ERR "digestsize(%u) > outputbuffer(%zu)\n",
 441                       crypto_hash_digestsize(tfm), sizeof(output));
 442                goto out;
 443        }
 444
 445        test_hash_sg_init(sg);
 446        for (i = 0; speed[i].blen != 0; i++) {
 447                if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
 448                        printk(KERN_ERR
 449                               "template (%u) too big for tvmem (%lu)\n",
 450                               speed[i].blen, TVMEMSIZE * PAGE_SIZE);
 451                        goto out;
 452                }
 453
 454                if (speed[i].klen)
 455                        crypto_hash_setkey(tfm, tvmem[0], speed[i].klen);
 456
 457                printk(KERN_INFO "test%3u "
 458                       "(%5u byte blocks,%5u bytes per update,%4u updates): ",
 459                       i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
 460
 461                if (sec)
 462                        ret = test_hash_jiffies(&desc, sg, speed[i].blen,
 463                                                speed[i].plen, output, sec);
 464                else
 465                        ret = test_hash_cycles(&desc, sg, speed[i].blen,
 466                                               speed[i].plen, output);
 467
 468                if (ret) {
 469                        printk(KERN_ERR "hashing failed ret=%d\n", ret);
 470                        break;
 471                }
 472        }
 473
 474out:
 475        crypto_free_hash(tfm);
 476}
 477
 478struct tcrypt_result {
 479        struct completion completion;
 480        int err;
 481};
 482
 483static void tcrypt_complete(struct crypto_async_request *req, int err)
 484{
 485        struct tcrypt_result *res = req->data;
 486
 487        if (err == -EINPROGRESS)
 488                return;
 489
 490        res->err = err;
 491        complete(&res->completion);
 492}
 493
 494static inline int do_one_ahash_op(struct ahash_request *req, int ret)
 495{
 496        if (ret == -EINPROGRESS || ret == -EBUSY) {
 497                struct tcrypt_result *tr = req->base.data;
 498
 499                ret = wait_for_completion_interruptible(&tr->completion);
 500                if (!ret)
 501                        ret = tr->err;
 502                INIT_COMPLETION(tr->completion);
 503        }
 504        return ret;
 505}
 506
 507static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
 508                                     char *out, int sec)
 509{
 510        unsigned long start, end;
 511        int bcount;
 512        int ret;
 513
 514        for (start = jiffies, end = start + sec * HZ, bcount = 0;
 515             time_before(jiffies, end); bcount++) {
 516                ret = do_one_ahash_op(req, crypto_ahash_digest(req));
 517                if (ret)
 518                        return ret;
 519        }
 520
 521        printk("%6u opers/sec, %9lu bytes/sec\n",
 522               bcount / sec, ((long)bcount * blen) / sec);
 523
 524        return 0;
 525}
 526
 527static int test_ahash_jiffies(struct ahash_request *req, int blen,
 528                              int plen, char *out, int sec)
 529{
 530        unsigned long start, end;
 531        int bcount, pcount;
 532        int ret;
 533
 534        if (plen == blen)
 535                return test_ahash_jiffies_digest(req, blen, out, sec);
 536
 537        for (start = jiffies, end = start + sec * HZ, bcount = 0;
 538             time_before(jiffies, end); bcount++) {
 539                ret = crypto_ahash_init(req);
 540                if (ret)
 541                        return ret;
 542                for (pcount = 0; pcount < blen; pcount += plen) {
 543                        ret = do_one_ahash_op(req, crypto_ahash_update(req));
 544                        if (ret)
 545                                return ret;
 546                }
 547                /* we assume there is enough space in 'out' for the result */
 548                ret = do_one_ahash_op(req, crypto_ahash_final(req));
 549                if (ret)
 550                        return ret;
 551        }
 552
 553        pr_cont("%6u opers/sec, %9lu bytes/sec\n",
 554                bcount / sec, ((long)bcount * blen) / sec);
 555
 556        return 0;
 557}
 558
 559static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
 560                                    char *out)
 561{
 562        unsigned long cycles = 0;
 563        int ret, i;
 564
 565        /* Warm-up run. */
 566        for (i = 0; i < 4; i++) {
 567                ret = do_one_ahash_op(req, crypto_ahash_digest(req));
 568                if (ret)
 569                        goto out;
 570        }
 571
 572        /* The real thing. */
 573        for (i = 0; i < 8; i++) {
 574                cycles_t start, end;
 575
 576                start = get_cycles();
 577
 578                ret = do_one_ahash_op(req, crypto_ahash_digest(req));
 579                if (ret)
 580                        goto out;
 581
 582                end = get_cycles();
 583
 584                cycles += end - start;
 585        }
 586
 587out:
 588        if (ret)
 589                return ret;
 590
 591        pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
 592                cycles / 8, cycles / (8 * blen));
 593
 594        return 0;
 595}
 596
 597static int test_ahash_cycles(struct ahash_request *req, int blen,
 598                             int plen, char *out)
 599{
 600        unsigned long cycles = 0;
 601        int i, pcount, ret;
 602
 603        if (plen == blen)
 604                return test_ahash_cycles_digest(req, blen, out);
 605
 606        /* Warm-up run. */
 607        for (i = 0; i < 4; i++) {
 608                ret = crypto_ahash_init(req);
 609                if (ret)
 610                        goto out;
 611                for (pcount = 0; pcount < blen; pcount += plen) {
 612                        ret = do_one_ahash_op(req, crypto_ahash_update(req));
 613                        if (ret)
 614                                goto out;
 615                }
 616                ret = do_one_ahash_op(req, crypto_ahash_final(req));
 617                if (ret)
 618                        goto out;
 619        }
 620
 621        /* The real thing. */
 622        for (i = 0; i < 8; i++) {
 623                cycles_t start, end;
 624
 625                start = get_cycles();
 626
 627                ret = crypto_ahash_init(req);
 628                if (ret)
 629                        goto out;
 630                for (pcount = 0; pcount < blen; pcount += plen) {
 631                        ret = do_one_ahash_op(req, crypto_ahash_update(req));
 632                        if (ret)
 633                                goto out;
 634                }
 635                ret = do_one_ahash_op(req, crypto_ahash_final(req));
 636                if (ret)
 637                        goto out;
 638
 639                end = get_cycles();
 640
 641                cycles += end - start;
 642        }
 643
 644out:
 645        if (ret)
 646                return ret;
 647
 648        pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
 649                cycles / 8, cycles / (8 * blen));
 650
 651        return 0;
 652}
 653
 654static void test_ahash_speed(const char *algo, unsigned int sec,
 655                             struct hash_speed *speed)
 656{
 657        struct scatterlist sg[TVMEMSIZE];
 658        struct tcrypt_result tresult;
 659        struct ahash_request *req;
 660        struct crypto_ahash *tfm;
 661        static char output[1024];
 662        int i, ret;
 663
 664        printk(KERN_INFO "\ntesting speed of async %s\n", algo);
 665
 666        tfm = crypto_alloc_ahash(algo, 0, 0);
 667        if (IS_ERR(tfm)) {
 668                pr_err("failed to load transform for %s: %ld\n",
 669                       algo, PTR_ERR(tfm));
 670                return;
 671        }
 672
 673        if (crypto_ahash_digestsize(tfm) > sizeof(output)) {
 674                pr_err("digestsize(%u) > outputbuffer(%zu)\n",
 675                       crypto_ahash_digestsize(tfm), sizeof(output));
 676                goto out;
 677        }
 678
 679        test_hash_sg_init(sg);
 680        req = ahash_request_alloc(tfm, GFP_KERNEL);
 681        if (!req) {
 682                pr_err("ahash request allocation failure\n");
 683                goto out;
 684        }
 685
 686        init_completion(&tresult.completion);
 687        ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 688                                   tcrypt_complete, &tresult);
 689
 690        for (i = 0; speed[i].blen != 0; i++) {
 691                if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
 692                        pr_err("template (%u) too big for tvmem (%lu)\n",
 693                               speed[i].blen, TVMEMSIZE * PAGE_SIZE);
 694                        break;
 695                }
 696
 697                pr_info("test%3u "
 698                        "(%5u byte blocks,%5u bytes per update,%4u updates): ",
 699                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
 700
 701                ahash_request_set_crypt(req, sg, output, speed[i].plen);
 702
 703                if (sec)
 704                        ret = test_ahash_jiffies(req, speed[i].blen,
 705                                                 speed[i].plen, output, sec);
 706                else
 707                        ret = test_ahash_cycles(req, speed[i].blen,
 708                                                speed[i].plen, output);
 709
 710                if (ret) {
 711                        pr_err("hashing failed ret=%d\n", ret);
 712                        break;
 713                }
 714        }
 715
 716        ahash_request_free(req);
 717
 718out:
 719        crypto_free_ahash(tfm);
 720}
 721
 722static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)
 723{
 724        if (ret == -EINPROGRESS || ret == -EBUSY) {
 725                struct tcrypt_result *tr = req->base.data;
 726
 727                ret = wait_for_completion_interruptible(&tr->completion);
 728                if (!ret)
 729                        ret = tr->err;
 730                INIT_COMPLETION(tr->completion);
 731        }
 732
 733        return ret;
 734}
 735
 736static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
 737                                int blen, int sec)
 738{
 739        unsigned long start, end;
 740        int bcount;
 741        int ret;
 742
 743        for (start = jiffies, end = start + sec * HZ, bcount = 0;
 744             time_before(jiffies, end); bcount++) {
 745                if (enc)
 746                        ret = do_one_acipher_op(req,
 747                                                crypto_ablkcipher_encrypt(req));
 748                else
 749                        ret = do_one_acipher_op(req,
 750                                                crypto_ablkcipher_decrypt(req));
 751
 752                if (ret)
 753                        return ret;
 754        }
 755
 756        pr_cont("%d operations in %d seconds (%ld bytes)\n",
 757                bcount, sec, (long)bcount * blen);
 758        return 0;
 759}
 760
 761static int test_acipher_cycles(struct ablkcipher_request *req, int enc,
 762                               int blen)
 763{
 764        unsigned long cycles = 0;
 765        int ret = 0;
 766        int i;
 767
 768        /* Warm-up run. */
 769        for (i = 0; i < 4; i++) {
 770                if (enc)
 771                        ret = do_one_acipher_op(req,
 772                                                crypto_ablkcipher_encrypt(req));
 773                else
 774                        ret = do_one_acipher_op(req,
 775                                                crypto_ablkcipher_decrypt(req));
 776
 777                if (ret)
 778                        goto out;
 779        }
 780
 781        /* The real thing. */
 782        for (i = 0; i < 8; i++) {
 783                cycles_t start, end;
 784
 785                start = get_cycles();
 786                if (enc)
 787                        ret = do_one_acipher_op(req,
 788                                                crypto_ablkcipher_encrypt(req));
 789                else
 790                        ret = do_one_acipher_op(req,
 791                                                crypto_ablkcipher_decrypt(req));
 792                end = get_cycles();
 793
 794                if (ret)
 795                        goto out;
 796
 797                cycles += end - start;
 798        }
 799
 800out:
 801        if (ret == 0)
 802                pr_cont("1 operation in %lu cycles (%d bytes)\n",
 803                        (cycles + 4) / 8, blen);
 804
 805        return ret;
 806}
 807
 808static void test_acipher_speed(const char *algo, int enc, unsigned int sec,
 809                               struct cipher_speed_template *template,
 810                               unsigned int tcount, u8 *keysize)
 811{
 812        unsigned int ret, i, j, iv_len;
 813        struct tcrypt_result tresult;
 814        const char *key;
 815        char iv[128];
 816        struct ablkcipher_request *req;
 817        struct crypto_ablkcipher *tfm;
 818        const char *e;
 819        u32 *b_size;
 820
 821        if (enc == ENCRYPT)
 822                e = "encryption";
 823        else
 824                e = "decryption";
 825
 826        pr_info("\ntesting speed of async %s %s\n", algo, e);
 827
 828        init_completion(&tresult.completion);
 829
 830        tfm = crypto_alloc_ablkcipher(algo, 0, 0);
 831
 832        if (IS_ERR(tfm)) {
 833                pr_err("failed to load transform for %s: %ld\n", algo,
 834                       PTR_ERR(tfm));
 835                return;
 836        }
 837
 838        req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
 839        if (!req) {
 840                pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
 841                       algo);
 842                goto out;
 843        }
 844
 845        ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 846                                        tcrypt_complete, &tresult);
 847
 848        i = 0;
 849        do {
 850                b_size = block_sizes;
 851
 852                do {
 853                        struct scatterlist sg[TVMEMSIZE];
 854
 855                        if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
 856                                pr_err("template (%u) too big for "
 857                                       "tvmem (%lu)\n", *keysize + *b_size,
 858                                       TVMEMSIZE * PAGE_SIZE);
 859                                goto out_free_req;
 860                        }
 861
 862                        pr_info("test %u (%d bit key, %d byte blocks): ", i,
 863                                *keysize * 8, *b_size);
 864
 865                        memset(tvmem[0], 0xff, PAGE_SIZE);
 866
 867                        /* set key, plain text and IV */
 868                        key = tvmem[0];
 869                        for (j = 0; j < tcount; j++) {
 870                                if (template[j].klen == *keysize) {
 871                                        key = template[j].key;
 872                                        break;
 873                                }
 874                        }
 875
 876                        crypto_ablkcipher_clear_flags(tfm, ~0);
 877
 878                        ret = crypto_ablkcipher_setkey(tfm, key, *keysize);
 879                        if (ret) {
 880                                pr_err("setkey() failed flags=%x\n",
 881                                        crypto_ablkcipher_get_flags(tfm));
 882                                goto out_free_req;
 883                        }
 884
 885                        sg_init_table(sg, TVMEMSIZE);
 886                        sg_set_buf(sg, tvmem[0] + *keysize,
 887                                   PAGE_SIZE - *keysize);
 888                        for (j = 1; j < TVMEMSIZE; j++) {
 889                                sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
 890                                memset(tvmem[j], 0xff, PAGE_SIZE);
 891                        }
 892
 893                        iv_len = crypto_ablkcipher_ivsize(tfm);
 894                        if (iv_len)
 895                                memset(&iv, 0xff, iv_len);
 896
 897                        ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv);
 898
 899                        if (sec)
 900                                ret = test_acipher_jiffies(req, enc,
 901                                                           *b_size, sec);
 902                        else
 903                                ret = test_acipher_cycles(req, enc,
 904                                                          *b_size);
 905
 906                        if (ret) {
 907                                pr_err("%s() failed flags=%x\n", e,
 908                                        crypto_ablkcipher_get_flags(tfm));
 909                                break;
 910                        }
 911                        b_size++;
 912                        i++;
 913                } while (*b_size);
 914                keysize++;
 915        } while (*keysize);
 916
 917out_free_req:
 918        ablkcipher_request_free(req);
 919out:
 920        crypto_free_ablkcipher(tfm);
 921}
 922
 923static void test_available(void)
 924{
 925        char **name = check;
 926
 927        while (*name) {
 928                printk("alg %s ", *name);
 929                printk(crypto_has_alg(*name, 0, 0) ?
 930                       "found\n" : "not found\n");
 931                name++;
 932        }
 933}
 934
 935static inline int tcrypt_test(const char *alg)
 936{
 937        int ret;
 938
 939        ret = alg_test(alg, alg, 0, 0);
 940        /* non-fips algs return -EINVAL in fips mode */
 941        if (fips_enabled && ret == -EINVAL)
 942                ret = 0;
 943        return ret;
 944}
 945
 946static int do_test(int m)
 947{
 948        int i;
 949        int ret = 0;
 950
 951        switch (m) {
 952        case 0:
 953                for (i = 1; i < 200; i++)
 954                        ret += do_test(i);
 955                break;
 956
 957        case 1:
 958                ret += tcrypt_test("md5");
 959                break;
 960
 961        case 2:
 962                ret += tcrypt_test("sha1");
 963                break;
 964
 965        case 3:
 966                ret += tcrypt_test("ecb(des)");
 967                ret += tcrypt_test("cbc(des)");
 968                break;
 969
 970        case 4:
 971                ret += tcrypt_test("ecb(des3_ede)");
 972                ret += tcrypt_test("cbc(des3_ede)");
 973                break;
 974
 975        case 5:
 976                ret += tcrypt_test("md4");
 977                break;
 978
 979        case 6:
 980                ret += tcrypt_test("sha256");
 981                break;
 982
 983        case 7:
 984                ret += tcrypt_test("ecb(blowfish)");
 985                ret += tcrypt_test("cbc(blowfish)");
 986                ret += tcrypt_test("ctr(blowfish)");
 987                break;
 988
 989        case 8:
 990                ret += tcrypt_test("ecb(twofish)");
 991                ret += tcrypt_test("cbc(twofish)");
 992                ret += tcrypt_test("ctr(twofish)");
 993                ret += tcrypt_test("lrw(twofish)");
 994                ret += tcrypt_test("xts(twofish)");
 995                break;
 996
 997        case 9:
 998                ret += tcrypt_test("ecb(serpent)");
 999                ret += tcrypt_test("cbc(serpent)");
1000                ret += tcrypt_test("ctr(serpent)");
1001                ret += tcrypt_test("lrw(serpent)");
1002                ret += tcrypt_test("xts(serpent)");
1003                break;
1004
1005        case 10:
1006                ret += tcrypt_test("ecb(aes)");
1007                ret += tcrypt_test("cbc(aes)");
1008                ret += tcrypt_test("lrw(aes)");
1009                ret += tcrypt_test("xts(aes)");
1010                ret += tcrypt_test("ctr(aes)");
1011                ret += tcrypt_test("rfc3686(ctr(aes))");
1012                break;
1013
1014        case 11:
1015                ret += tcrypt_test("sha384");
1016                break;
1017
1018        case 12:
1019                ret += tcrypt_test("sha512");
1020                break;
1021
1022        case 13:
1023                ret += tcrypt_test("deflate");
1024                break;
1025
1026        case 14:
1027                ret += tcrypt_test("ecb(cast5)");
1028                break;
1029
1030        case 15:
1031                ret += tcrypt_test("ecb(cast6)");
1032                break;
1033
1034        case 16:
1035                ret += tcrypt_test("ecb(arc4)");
1036                break;
1037
1038        case 17:
1039                ret += tcrypt_test("michael_mic");
1040                break;
1041
1042        case 18:
1043                ret += tcrypt_test("crc32c");
1044                break;
1045
1046        case 19:
1047                ret += tcrypt_test("ecb(tea)");
1048                break;
1049
1050        case 20:
1051                ret += tcrypt_test("ecb(xtea)");
1052                break;
1053
1054        case 21:
1055                ret += tcrypt_test("ecb(khazad)");
1056                break;
1057
1058        case 22:
1059                ret += tcrypt_test("wp512");
1060                break;
1061
1062        case 23:
1063                ret += tcrypt_test("wp384");
1064                break;
1065
1066        case 24:
1067                ret += tcrypt_test("wp256");
1068                break;
1069
1070        case 25:
1071                ret += tcrypt_test("ecb(tnepres)");
1072                break;
1073
1074        case 26:
1075                ret += tcrypt_test("ecb(anubis)");
1076                ret += tcrypt_test("cbc(anubis)");
1077                break;
1078
1079        case 27:
1080                ret += tcrypt_test("tgr192");
1081                break;
1082
1083        case 28:
1084
1085                ret += tcrypt_test("tgr160");
1086                break;
1087
1088        case 29:
1089                ret += tcrypt_test("tgr128");
1090                break;
1091
1092        case 30:
1093                ret += tcrypt_test("ecb(xeta)");
1094                break;
1095
1096        case 31:
1097                ret += tcrypt_test("pcbc(fcrypt)");
1098                break;
1099
1100        case 32:
1101                ret += tcrypt_test("ecb(camellia)");
1102                ret += tcrypt_test("cbc(camellia)");
1103                break;
1104        case 33:
1105                ret += tcrypt_test("sha224");
1106                break;
1107
1108        case 34:
1109                ret += tcrypt_test("salsa20");
1110                break;
1111
1112        case 35:
1113                ret += tcrypt_test("gcm(aes)");
1114                break;
1115
1116        case 36:
1117                ret += tcrypt_test("lzo");
1118                break;
1119
1120        case 37:
1121                ret += tcrypt_test("ccm(aes)");
1122                break;
1123
1124        case 38:
1125                ret += tcrypt_test("cts(cbc(aes))");
1126                break;
1127
1128        case 39:
1129                ret += tcrypt_test("rmd128");
1130                break;
1131
1132        case 40:
1133                ret += tcrypt_test("rmd160");
1134                break;
1135
1136        case 41:
1137                ret += tcrypt_test("rmd256");
1138                break;
1139
1140        case 42:
1141                ret += tcrypt_test("rmd320");
1142                break;
1143
1144        case 43:
1145                ret += tcrypt_test("ecb(seed)");
1146                break;
1147
1148        case 44:
1149                ret += tcrypt_test("zlib");
1150                break;
1151
1152        case 45:
1153                ret += tcrypt_test("rfc4309(ccm(aes))");
1154                break;
1155
1156        case 100:
1157                ret += tcrypt_test("hmac(md5)");
1158                break;
1159
1160        case 101:
1161                ret += tcrypt_test("hmac(sha1)");
1162                break;
1163
1164        case 102:
1165                ret += tcrypt_test("hmac(sha256)");
1166                break;
1167
1168        case 103:
1169                ret += tcrypt_test("hmac(sha384)");
1170                break;
1171
1172        case 104:
1173                ret += tcrypt_test("hmac(sha512)");
1174                break;
1175
1176        case 105:
1177                ret += tcrypt_test("hmac(sha224)");
1178                break;
1179
1180        case 106:
1181                ret += tcrypt_test("xcbc(aes)");
1182                break;
1183
1184        case 107:
1185                ret += tcrypt_test("hmac(rmd128)");
1186                break;
1187
1188        case 108:
1189                ret += tcrypt_test("hmac(rmd160)");
1190                break;
1191
1192        case 109:
1193                ret += tcrypt_test("vmac(aes)");
1194                break;
1195
1196        case 150:
1197                ret += tcrypt_test("ansi_cprng");
1198                break;
1199
1200        case 151:
1201                ret += tcrypt_test("rfc4106(gcm(aes))");
1202                break;
1203
1204        case 200:
1205                test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1206                                speed_template_16_24_32);
1207                test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1208                                speed_template_16_24_32);
1209                test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1210                                speed_template_16_24_32);
1211                test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1212                                speed_template_16_24_32);
1213                test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1214                                speed_template_32_40_48);
1215                test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1216                                speed_template_32_40_48);
1217                test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1218                                speed_template_32_48_64);
1219                test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1220                                speed_template_32_48_64);
1221                test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1222                                speed_template_16_24_32);
1223                test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1224                                speed_template_16_24_32);
1225                break;
1226
1227        case 201:
1228                test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1229                                des3_speed_template, DES3_SPEED_VECTORS,
1230                                speed_template_24);
1231                test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1232                                des3_speed_template, DES3_SPEED_VECTORS,
1233                                speed_template_24);
1234                test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1235                                des3_speed_template, DES3_SPEED_VECTORS,
1236                                speed_template_24);
1237                test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1238                                des3_speed_template, DES3_SPEED_VECTORS,
1239                                speed_template_24);
1240                break;
1241
1242        case 202:
1243                test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1244                                speed_template_16_24_32);
1245                test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1246                                speed_template_16_24_32);
1247                test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1248                                speed_template_16_24_32);
1249                test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1250                                speed_template_16_24_32);
1251                test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1252                                speed_template_16_24_32);
1253                test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1254                                speed_template_16_24_32);
1255                test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1256                                speed_template_32_40_48);
1257                test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1258                                speed_template_32_40_48);
1259                test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1260                                speed_template_32_48_64);
1261                test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1262                                speed_template_32_48_64);
1263                break;
1264
1265        case 203:
1266                test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1267                                  speed_template_8_32);
1268                test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1269                                  speed_template_8_32);
1270                test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1271                                  speed_template_8_32);
1272                test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1273                                  speed_template_8_32);
1274                test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
1275                                  speed_template_8_32);
1276                test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
1277                                  speed_template_8_32);
1278                break;
1279
1280        case 204:
1281                test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1282                                  speed_template_8);
1283                test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1284                                  speed_template_8);
1285                test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1286                                  speed_template_8);
1287                test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1288                                  speed_template_8);
1289                break;
1290
1291        case 205:
1292                test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1293                                speed_template_16_24_32);
1294                test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1295                                speed_template_16_24_32);
1296                test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1297                                speed_template_16_24_32);
1298                test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1299                                speed_template_16_24_32);
1300                test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
1301                                speed_template_16_24_32);
1302                test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
1303                                speed_template_16_24_32);
1304                test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
1305                                speed_template_32_40_48);
1306                test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
1307                                speed_template_32_40_48);
1308                test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
1309                                speed_template_32_48_64);
1310                test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
1311                                speed_template_32_48_64);
1312                break;
1313
1314        case 206:
1315                test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1316                                  speed_template_16_32);
1317                break;
1318
1319        case 207:
1320                test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1321                                  speed_template_16_32);
1322                test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1323                                  speed_template_16_32);
1324                test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1325                                  speed_template_16_32);
1326                test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1327                                  speed_template_16_32);
1328                test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1329                                  speed_template_16_32);
1330                test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1331                                  speed_template_16_32);
1332                test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1333                                  speed_template_32_48);
1334                test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1335                                  speed_template_32_48);
1336                test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1337                                  speed_template_32_64);
1338                test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1339                                  speed_template_32_64);
1340                break;
1341
1342        case 300:
1343                /* fall through */
1344
1345        case 301:
1346                test_hash_speed("md4", sec, generic_hash_speed_template);
1347                if (mode > 300 && mode < 400) break;
1348
1349        case 302:
1350                test_hash_speed("md5", sec, generic_hash_speed_template);
1351                if (mode > 300 && mode < 400) break;
1352
1353        case 303:
1354                test_hash_speed("sha1", sec, generic_hash_speed_template);
1355                if (mode > 300 && mode < 400) break;
1356
1357        case 304:
1358                test_hash_speed("sha256", sec, generic_hash_speed_template);
1359                if (mode > 300 && mode < 400) break;
1360
1361        case 305:
1362                test_hash_speed("sha384", sec, generic_hash_speed_template);
1363                if (mode > 300 && mode < 400) break;
1364
1365        case 306:
1366                test_hash_speed("sha512", sec, generic_hash_speed_template);
1367                if (mode > 300 && mode < 400) break;
1368
1369        case 307:
1370                test_hash_speed("wp256", sec, generic_hash_speed_template);
1371                if (mode > 300 && mode < 400) break;
1372
1373        case 308:
1374                test_hash_speed("wp384", sec, generic_hash_speed_template);
1375                if (mode > 300 && mode < 400) break;
1376
1377        case 309:
1378                test_hash_speed("wp512", sec, generic_hash_speed_template);
1379                if (mode > 300 && mode < 400) break;
1380
1381        case 310:
1382                test_hash_speed("tgr128", sec, generic_hash_speed_template);
1383                if (mode > 300 && mode < 400) break;
1384
1385        case 311:
1386                test_hash_speed("tgr160", sec, generic_hash_speed_template);
1387                if (mode > 300 && mode < 400) break;
1388
1389        case 312:
1390                test_hash_speed("tgr192", sec, generic_hash_speed_template);
1391                if (mode > 300 && mode < 400) break;
1392
1393        case 313:
1394                test_hash_speed("sha224", sec, generic_hash_speed_template);
1395                if (mode > 300 && mode < 400) break;
1396
1397        case 314:
1398                test_hash_speed("rmd128", sec, generic_hash_speed_template);
1399                if (mode > 300 && mode < 400) break;
1400
1401        case 315:
1402                test_hash_speed("rmd160", sec, generic_hash_speed_template);
1403                if (mode > 300 && mode < 400) break;
1404
1405        case 316:
1406                test_hash_speed("rmd256", sec, generic_hash_speed_template);
1407                if (mode > 300 && mode < 400) break;
1408
1409        case 317:
1410                test_hash_speed("rmd320", sec, generic_hash_speed_template);
1411                if (mode > 300 && mode < 400) break;
1412
1413        case 318:
1414                test_hash_speed("ghash-generic", sec, hash_speed_template_16);
1415                if (mode > 300 && mode < 400) break;
1416
1417        case 399:
1418                break;
1419
1420        case 400:
1421                /* fall through */
1422
1423        case 401:
1424                test_ahash_speed("md4", sec, generic_hash_speed_template);
1425                if (mode > 400 && mode < 500) break;
1426
1427        case 402:
1428                test_ahash_speed("md5", sec, generic_hash_speed_template);
1429                if (mode > 400 && mode < 500) break;
1430
1431        case 403:
1432                test_ahash_speed("sha1", sec, generic_hash_speed_template);
1433                if (mode > 400 && mode < 500) break;
1434
1435        case 404:
1436                test_ahash_speed("sha256", sec, generic_hash_speed_template);
1437                if (mode > 400 && mode < 500) break;
1438
1439        case 405:
1440                test_ahash_speed("sha384", sec, generic_hash_speed_template);
1441                if (mode > 400 && mode < 500) break;
1442
1443        case 406:
1444                test_ahash_speed("sha512", sec, generic_hash_speed_template);
1445                if (mode > 400 && mode < 500) break;
1446
1447        case 407:
1448                test_ahash_speed("wp256", sec, generic_hash_speed_template);
1449                if (mode > 400 && mode < 500) break;
1450
1451        case 408:
1452                test_ahash_speed("wp384", sec, generic_hash_speed_template);
1453                if (mode > 400 && mode < 500) break;
1454
1455        case 409:
1456                test_ahash_speed("wp512", sec, generic_hash_speed_template);
1457                if (mode > 400 && mode < 500) break;
1458
1459        case 410:
1460                test_ahash_speed("tgr128", sec, generic_hash_speed_template);
1461                if (mode > 400 && mode < 500) break;
1462
1463        case 411:
1464                test_ahash_speed("tgr160", sec, generic_hash_speed_template);
1465                if (mode > 400 && mode < 500) break;
1466
1467        case 412:
1468                test_ahash_speed("tgr192", sec, generic_hash_speed_template);
1469                if (mode > 400 && mode < 500) break;
1470
1471        case 413:
1472                test_ahash_speed("sha224", sec, generic_hash_speed_template);
1473                if (mode > 400 && mode < 500) break;
1474
1475        case 414:
1476                test_ahash_speed("rmd128", sec, generic_hash_speed_template);
1477                if (mode > 400 && mode < 500) break;
1478
1479        case 415:
1480                test_ahash_speed("rmd160", sec, generic_hash_speed_template);
1481                if (mode > 400 && mode < 500) break;
1482
1483        case 416:
1484                test_ahash_speed("rmd256", sec, generic_hash_speed_template);
1485                if (mode > 400 && mode < 500) break;
1486
1487        case 417:
1488                test_ahash_speed("rmd320", sec, generic_hash_speed_template);
1489                if (mode > 400 && mode < 500) break;
1490
1491        case 499:
1492                break;
1493
1494        case 500:
1495                test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1496                                   speed_template_16_24_32);
1497                test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1498                                   speed_template_16_24_32);
1499                test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1500                                   speed_template_16_24_32);
1501                test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1502                                   speed_template_16_24_32);
1503                test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1504                                   speed_template_32_40_48);
1505                test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1506                                   speed_template_32_40_48);
1507                test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1508                                   speed_template_32_48_64);
1509                test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1510                                   speed_template_32_48_64);
1511                test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1512                                   speed_template_16_24_32);
1513                test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1514                                   speed_template_16_24_32);
1515                break;
1516
1517        case 501:
1518                test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1519                                   des3_speed_template, DES3_SPEED_VECTORS,
1520                                   speed_template_24);
1521                test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
1522                                   des3_speed_template, DES3_SPEED_VECTORS,
1523                                   speed_template_24);
1524                test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1525                                   des3_speed_template, DES3_SPEED_VECTORS,
1526                                   speed_template_24);
1527                test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
1528                                   des3_speed_template, DES3_SPEED_VECTORS,
1529                                   speed_template_24);
1530                break;
1531
1532        case 502:
1533                test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1534                                   speed_template_8);
1535                test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1536                                   speed_template_8);
1537                test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1538                                   speed_template_8);
1539                test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1540                                   speed_template_8);
1541                break;
1542
1543        case 503:
1544                test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1545                                   speed_template_16_32);
1546                test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1547                                   speed_template_16_32);
1548                test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1549                                   speed_template_16_32);
1550                test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1551                                   speed_template_16_32);
1552                test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1553                                   speed_template_16_32);
1554                test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1555                                   speed_template_16_32);
1556                test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1557                                   speed_template_32_48);
1558                test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1559                                   speed_template_32_48);
1560                test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
1561                                   speed_template_32_64);
1562                test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
1563                                   speed_template_32_64);
1564                break;
1565
1566        case 1000:
1567                test_available();
1568                break;
1569        }
1570
1571        return ret;
1572}
1573
1574static int do_alg_test(const char *alg, u32 type, u32 mask)
1575{
1576        return crypto_has_alg(alg, type, mask ?: CRYPTO_ALG_TYPE_MASK) ?
1577               0 : -ENOENT;
1578}
1579
1580static int __init tcrypt_mod_init(void)
1581{
1582        int err = -ENOMEM;
1583        int i;
1584
1585        for (i = 0; i < TVMEMSIZE; i++) {
1586                tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
1587                if (!tvmem[i])
1588                        goto err_free_tv;
1589        }
1590
1591        if (alg)
1592                err = do_alg_test(alg, type, mask);
1593        else
1594                err = do_test(mode);
1595
1596        if (err) {
1597                printk(KERN_ERR "tcrypt: one or more tests failed!\n");
1598                goto err_free_tv;
1599        }
1600
1601        /* We intentionaly return -EAGAIN to prevent keeping the module,
1602         * unless we're running in fips mode. It does all its work from
1603         * init() and doesn't offer any runtime functionality, but in
1604         * the fips case, checking for a successful load is helpful.
1605         * => we don't need it in the memory, do we?
1606         *                                        -- mludvig
1607         */
1608        if (!fips_enabled)
1609                err = -EAGAIN;
1610
1611err_free_tv:
1612        for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
1613                free_page((unsigned long)tvmem[i]);
1614
1615        return err;
1616}
1617
1618/*
1619 * If an init function is provided, an exit function must also be provided
1620 * to allow module unload.
1621 */
1622static void __exit tcrypt_mod_fini(void) { }
1623
1624module_init(tcrypt_mod_init);
1625module_exit(tcrypt_mod_fini);
1626
1627module_param(alg, charp, 0);
1628module_param(type, uint, 0);
1629module_param(mask, uint, 0);
1630module_param(mode, int, 0);
1631module_param(sec, uint, 0);
1632MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1633                      "(defaults to zero which uses CPU cycles instead)");
1634
1635MODULE_LICENSE("GPL");
1636MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1637MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
1638
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.