SAFE public projects git trees. - safe/jmp/linux-2.6/blob - crypto/tcrypt.c

   1 /*
   2  * Quick & dirty crypto testing module.
   3  *
   4  * This will only exist until we have a better testing mechanism
   5  * (e.g. a char device).
   6  *
   7  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
   8  * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
   9  * Copyright (c) 2007 Nokia Siemens Networks
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU General Public License as published by the Free
  13  * Software Foundation; either version 2 of the License, or (at your option)
  14  * any later version.
  15  *
  16  * 2007-11-13 Added GCM tests
  17  * 2007-11-13 Added AEAD support
  18  * 2007-11-06 Added SHA-224 and SHA-224-HMAC tests
  19  * 2006-12-07 Added SHA384 HMAC and SHA512 HMAC tests
  20  * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
  21  * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
  22  *
  23  */
  24
  25 #include <linux/err.h>
  26 #include <linux/init.h>
  27 #include <linux/module.h>
  28 #include <linux/mm.h>
  29 #include <linux/slab.h>
  30 #include <linux/scatterlist.h>
  31 #include <linux/string.h>
  32 #include <linux/crypto.h>
  33 #include <linux/highmem.h>
  34 #include <linux/moduleparam.h>
  35 #include <linux/jiffies.h>
  36 #include <linux/timex.h>
  37 #include <linux/interrupt.h>
  38 #include "tcrypt.h"
  39
  40 /*
  41  * Need to kmalloc() memory for testing kmap().
  42  */
  43 #define TVMEMSIZE       16384
  44 #define XBUFSIZE        32768
  45
  46 /*
  47  * Indexes into the xbuf to simulate cross-page access.
  48  */
  49 #define IDX1            37
  50 #define IDX2            32400
  51 #define IDX3            1
  52 #define IDX4            8193
  53 #define IDX5            22222
  54 #define IDX6            17101
  55 #define IDX7            27333
  56 #define IDX8            3000
  57
  58 /*
  59 * Used by test_cipher()
  60 */
  61 #define ENCRYPT 1
  62 #define DECRYPT 0
  63
  64 struct tcrypt_result {
  65         struct completion completion;
  66         int err;
  67 };
  68
  69 static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
  70
  71 /*
  72  * Used by test_cipher_speed()
  73  */
  74 static unsigned int sec;
  75
  76 static int mode;
  77 static char *xbuf;
  78 static char *axbuf;
  79 static char *tvmem;
  80
  81 static char *check[] = {
  82         "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
  83         "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
  84         "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
  85         "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta",  "fcrypt",
  86         "camellia", "seed", "salsa20", "lzo", "cts", NULL
  87 };
  88
  89 static void hexdump(unsigned char *buf, unsigned int len)
  90 {
  91         print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET,
  92                         16, 1,
  93                         buf, len, false);
  94 }
  95
  96 static void tcrypt_complete(struct crypto_async_request *req, int err)
  97 {
  98         struct tcrypt_result *res = req->data;
  99
 100         if (err == -EINPROGRESS)
 101                 return;
 102
 103         res->err = err;
 104         complete(&res->completion);
 105 }
 106
 107 static void test_hash(char *algo, struct hash_testvec *template,
 108                       unsigned int tcount)
 109 {
 110         unsigned int i, j, k, temp;
 111         struct scatterlist sg[8];
 112         char result[64];
 113         struct crypto_hash *tfm;
 114         struct hash_desc desc;
 115         int ret;
 116         void *hash_buff;
 117
 118         printk("\ntesting %s\n", algo);
 119
 120         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
 121         if (IS_ERR(tfm)) {
 122                 printk("failed to load transform for %s: %ld\n", algo,
 123                        PTR_ERR(tfm));
 124                 return;
 125         }
 126
 127         desc.tfm = tfm;
 128         desc.flags = 0;
 129
 130         for (i = 0; i < tcount; i++) {
 131                 printk("test %u:\n", i + 1);
 132                 memset(result, 0, 64);
 133
 134                 hash_buff = kzalloc(template[i].psize, GFP_KERNEL);
 135                 if (!hash_buff)
 136                         continue;
 137
 138                 memcpy(hash_buff, template[i].plaintext, template[i].psize);
 139                 sg_init_one(&sg[0], hash_buff, template[i].psize);
 140
 141                 if (template[i].ksize) {
 142                         ret = crypto_hash_setkey(tfm, template[i].key,
 143                                                  template[i].ksize);
 144                         if (ret) {
 145                                 printk("setkey() failed ret=%d\n", ret);
 146                                 kfree(hash_buff);
 147                                 goto out;
 148                         }
 149                 }
 150
 151                 ret = crypto_hash_digest(&desc, sg, template[i].psize, result);
 152                 if (ret) {
 153                         printk("digest () failed ret=%d\n", ret);
 154                         kfree(hash_buff);
 155                         goto out;
 156                 }
 157
 158                 hexdump(result, crypto_hash_digestsize(tfm));
 159                 printk("%s\n",
 160                        memcmp(result, template[i].digest,
 161                               crypto_hash_digestsize(tfm)) ?
 162                        "fail" : "pass");
 163                 kfree(hash_buff);
 164         }
 165
 166         printk("testing %s across pages\n", algo);
 167
 168         /* setup the dummy buffer first */
 169         memset(xbuf, 0, XBUFSIZE);
 170
 171         j = 0;
 172         for (i = 0; i < tcount; i++) {
 173                 if (template[i].np) {
 174                         j++;
 175                         printk("test %u:\n", j);
 176                         memset(result, 0, 64);
 177
 178                         temp = 0;
 179                         sg_init_table(sg, template[i].np);
 180                         for (k = 0; k < template[i].np; k++) {
 181                                 memcpy(&xbuf[IDX[k]],
 182                                        template[i].plaintext + temp,
 183                                        template[i].tap[k]);
 184                                 temp += template[i].tap[k];
 185                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 186                                             template[i].tap[k]);
 187                         }
 188
 189                         if (template[i].ksize) {
 190                                 ret = crypto_hash_setkey(tfm, template[i].key,
 191                                                          template[i].ksize);
 192
 193                                 if (ret) {
 194                                         printk("setkey() failed ret=%d\n", ret);
 195                                         goto out;
 196                                 }
 197                         }
 198
 199                         ret = crypto_hash_digest(&desc, sg, template[i].psize,
 200                                                  result);
 201                         if (ret) {
 202                                 printk("digest () failed ret=%d\n", ret);
 203                                 goto out;
 204                         }
 205
 206                         hexdump(result, crypto_hash_digestsize(tfm));
 207                         printk("%s\n",
 208                                memcmp(result, template[i].digest,
 209                                       crypto_hash_digestsize(tfm)) ?
 210                                "fail" : "pass");
 211                 }
 212         }
 213
 214 out:
 215         crypto_free_hash(tfm);
 216 }
 217
 218 static void test_aead(char *algo, int enc, struct aead_testvec *template,
 219                       unsigned int tcount)
 220 {
 221         unsigned int ret, i, j, k, temp;
 222         char *q;
 223         struct crypto_aead *tfm;
 224         char *key;
 225         struct aead_request *req;
 226         struct scatterlist sg[8];
 227         struct scatterlist asg[8];
 228         const char *e;
 229         struct tcrypt_result result;
 230         unsigned int authsize;
 231         void *input;
 232         void *assoc;
 233         char iv[MAX_IVLEN];
 234
 235         if (enc == ENCRYPT)
 236                 e = "encryption";
 237         else
 238                 e = "decryption";
 239
 240         printk(KERN_INFO "\ntesting %s %s\n", algo, e);
 241
 242         init_completion(&result.completion);
 243
 244         tfm = crypto_alloc_aead(algo, 0, 0);
 245
 246         if (IS_ERR(tfm)) {
 247                 printk(KERN_INFO "failed to load transform for %s: %ld\n",
 248                        algo, PTR_ERR(tfm));
 249                 return;
 250         }
 251
 252         req = aead_request_alloc(tfm, GFP_KERNEL);
 253         if (!req) {
 254                 printk(KERN_INFO "failed to allocate request for %s\n", algo);
 255                 goto out;
 256         }
 257
 258         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 259                                   tcrypt_complete, &result);
 260
 261         for (i = 0, j = 0; i < tcount; i++) {
 262                 if (!template[i].np) {
 263                         printk(KERN_INFO "test %u (%d bit key):\n",
 264                                ++j, template[i].klen * 8);
 265
 266                         /* some tepmplates have no input data but they will
 267                          * touch input
 268                          */
 269                         input = kzalloc(template[i].ilen + template[i].rlen, GFP_KERNEL);
 270                         if (!input)
 271                                 continue;
 272
 273                         assoc = kzalloc(template[i].alen, GFP_KERNEL);
 274                         if (!assoc) {
 275                                 kfree(input);
 276                                 continue;
 277                         }
 278
 279                         memcpy(input, template[i].input, template[i].ilen);
 280                         memcpy(assoc, template[i].assoc, template[i].alen);
 281                         if (template[i].iv)
 282                                 memcpy(iv, template[i].iv, MAX_IVLEN);
 283                         else
 284                                 memset(iv, 0, MAX_IVLEN);
 285
 286                         crypto_aead_clear_flags(tfm, ~0);
 287                         if (template[i].wk)
 288                                 crypto_aead_set_flags(
 289                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 290
 291                         if (template[i].key)
 292                                 key = template[i].key;
 293                         else
 294                                 key = kzalloc(template[i].klen, GFP_KERNEL);
 295
 296                         ret = crypto_aead_setkey(tfm, key,
 297                                                  template[i].klen);
 298                         if (ret) {
 299                                 printk(KERN_INFO "setkey() failed flags=%x\n",
 300                                        crypto_aead_get_flags(tfm));
 301
 302                                 if (!template[i].fail)
 303                                         goto next_one;
 304                         }
 305
 306                         authsize = abs(template[i].rlen - template[i].ilen);
 307                         ret = crypto_aead_setauthsize(tfm, authsize);
 308                         if (ret) {
 309                                 printk(KERN_INFO
 310                                        "failed to set authsize = %u\n",
 311                                        authsize);
 312                                 goto next_one;
 313                         }
 314
 315                         sg_init_one(&sg[0], input,
 316                                     template[i].ilen + (enc ? authsize : 0));
 317
 318                         sg_init_one(&asg[0], assoc, template[i].alen);
 319
 320                         aead_request_set_crypt(req, sg, sg,
 321                                                template[i].ilen, iv);
 322
 323                         aead_request_set_assoc(req, asg, template[i].alen);
 324
 325                         ret = enc ?
 326                                 crypto_aead_encrypt(req) :
 327                                 crypto_aead_decrypt(req);
 328
 329                         switch (ret) {
 330                         case 0:
 331                                 break;
 332                         case -EINPROGRESS:
 333                         case -EBUSY:
 334                                 ret = wait_for_completion_interruptible(
 335                                         &result.completion);
 336                                 if (!ret && !(ret = result.err)) {
 337                                         INIT_COMPLETION(result.completion);
 338                                         break;
 339                                 }
 340                                 /* fall through */
 341                         default:
 342                                 printk(KERN_INFO "%s () failed err=%d\n",
 343                                        e, -ret);
 344                                 goto next_one;
 345                         }
 346
 347                         q = kmap(sg_page(&sg[0])) + sg[0].offset;
 348                         hexdump(q, template[i].rlen);
 349
 350                         printk(KERN_INFO "enc/dec: %s\n",
 351                                memcmp(q, template[i].result,
 352                                       template[i].rlen) ? "fail" : "pass");
 353                         kunmap(sg_page(&sg[0]));
 354 next_one:
 355                         if (!template[i].key)
 356                                 kfree(key);
 357                         kfree(assoc);
 358                         kfree(input);
 359                 }
 360         }
 361
 362         printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e);
 363         memset(xbuf, 0, XBUFSIZE);
 364         memset(axbuf, 0, XBUFSIZE);
 365
 366         for (i = 0, j = 0; i < tcount; i++) {
 367                 if (template[i].np) {
 368                         printk(KERN_INFO "test %u (%d bit key):\n",
 369                                ++j, template[i].klen * 8);
 370
 371                         if (template[i].iv)
 372                                 memcpy(iv, template[i].iv, MAX_IVLEN);
 373                         else
 374                                 memset(iv, 0, MAX_IVLEN);
 375
 376                         crypto_aead_clear_flags(tfm, ~0);
 377                         if (template[i].wk)
 378                                 crypto_aead_set_flags(
 379                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 380                         key = template[i].key;
 381
 382                         ret = crypto_aead_setkey(tfm, key, template[i].klen);
 383                         if (ret) {
 384                                 printk(KERN_INFO "setkey() failed flags=%x\n",
 385                                        crypto_aead_get_flags(tfm));
 386
 387                                 if (!template[i].fail)
 388                                         goto out;
 389                         }
 390
 391                         sg_init_table(sg, template[i].np);
 392                         for (k = 0, temp = 0; k < template[i].np; k++) {
 393                                 memcpy(&xbuf[IDX[k]],
 394                                        template[i].input + temp,
 395                                        template[i].tap[k]);
 396                                 temp += template[i].tap[k];
 397                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 398                                            template[i].tap[k]);
 399                         }
 400
 401                         authsize = abs(template[i].rlen - template[i].ilen);
 402                         ret = crypto_aead_setauthsize(tfm, authsize);
 403                         if (ret) {
 404                                 printk(KERN_INFO
 405                                        "failed to set authsize = %u\n",
 406                                        authsize);
 407                                 goto out;
 408                         }
 409
 410                         if (enc)
 411                                 sg[k - 1].length += authsize;
 412
 413                         sg_init_table(asg, template[i].anp);
 414                         for (k = 0, temp = 0; k < template[i].anp; k++) {
 415                                 memcpy(&axbuf[IDX[k]],
 416                                        template[i].assoc + temp,
 417                                        template[i].atap[k]);
 418                                 temp += template[i].atap[k];
 419                                 sg_set_buf(&asg[k], &axbuf[IDX[k]],
 420                                            template[i].atap[k]);
 421                         }
 422
 423                         aead_request_set_crypt(req, sg, sg,
 424                                                template[i].ilen,
 425                                                iv);
 426
 427                         aead_request_set_assoc(req, asg, template[i].alen);
 428
 429                         ret = enc ?
 430                                 crypto_aead_encrypt(req) :
 431                                 crypto_aead_decrypt(req);
 432
 433                         switch (ret) {
 434                         case 0:
 435                                 break;
 436                         case -EINPROGRESS:
 437                         case -EBUSY:
 438                                 ret = wait_for_completion_interruptible(
 439                                         &result.completion);
 440                                 if (!ret && !(ret = result.err)) {
 441                                         INIT_COMPLETION(result.completion);
 442                                         break;
 443                                 }
 444                                 /* fall through */
 445                         default:
 446                                 printk(KERN_INFO "%s () failed err=%d\n",
 447                                        e, -ret);
 448                                 goto out;
 449                         }
 450
 451                         for (k = 0, temp = 0; k < template[i].np; k++) {
 452                                 printk(KERN_INFO "page %u\n", k);
 453                                 q = kmap(sg_page(&sg[k])) + sg[k].offset;
 454                                 hexdump(q, template[i].tap[k]);
 455                                 printk(KERN_INFO "%s\n",
 456                                        memcmp(q, template[i].result + temp,
 457                                               template[i].tap[k] -
 458                                               (k < template[i].np - 1 || enc ?
 459                                                0 : authsize)) ?
 460                                        "fail" : "pass");
 461
 462                                 temp += template[i].tap[k];
 463                                 kunmap(sg_page(&sg[k]));
 464                         }
 465                 }
 466         }
 467
 468 out:
 469         crypto_free_aead(tfm);
 470         aead_request_free(req);
 471 }
 472
 473 static void test_cipher(char *algo, int enc,
 474                         struct cipher_testvec *template, unsigned int tcount)
 475 {
 476         unsigned int ret, i, j, k, temp;
 477         char *q;
 478         struct crypto_ablkcipher *tfm;
 479         struct ablkcipher_request *req;
 480         struct scatterlist sg[8];
 481         const char *e;
 482         struct tcrypt_result result;
 483         void *data;
 484         char iv[MAX_IVLEN];
 485
 486         if (enc == ENCRYPT)
 487                 e = "encryption";
 488         else
 489                 e = "decryption";
 490
 491         printk("\ntesting %s %s\n", algo, e);
 492
 493         init_completion(&result.completion);
 494         tfm = crypto_alloc_ablkcipher(algo, 0, 0);
 495
 496         if (IS_ERR(tfm)) {
 497                 printk("failed to load transform for %s: %ld\n", algo,
 498                        PTR_ERR(tfm));
 499                 return;
 500         }
 501
 502         req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
 503         if (!req) {
 504                 printk("failed to allocate request for %s\n", algo);
 505                 goto out;
 506         }
 507
 508         ablkcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 509                                         tcrypt_complete, &result);
 510
 511         j = 0;
 512         for (i = 0; i < tcount; i++) {
 513
 514                 data = kzalloc(template[i].ilen, GFP_KERNEL);
 515                 if (!data)
 516                         continue;
 517
 518                 memcpy(data, template[i].input, template[i].ilen);
 519                 if (template[i].iv)
 520                         memcpy(iv, template[i].iv, MAX_IVLEN);
 521                 else
 522                         memset(iv, 0, MAX_IVLEN);
 523
 524                 if (!(template[i].np)) {
 525                         j++;
 526                         printk("test %u (%d bit key):\n",
 527                         j, template[i].klen * 8);
 528
 529                         crypto_ablkcipher_clear_flags(tfm, ~0);
 530                         if (template[i].wk)
 531                                 crypto_ablkcipher_set_flags(
 532                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 533
 534                         ret = crypto_ablkcipher_setkey(tfm, template[i].key,
 535                                                        template[i].klen);
 536                         if (ret) {
 537                                 printk("setkey() failed flags=%x\n",
 538                                        crypto_ablkcipher_get_flags(tfm));
 539
 540                                 if (!template[i].fail) {
 541                                         kfree(data);
 542                                         goto out;
 543                                 }
 544                         }
 545
 546                         sg_init_one(&sg[0], data, template[i].ilen);
 547
 548                         ablkcipher_request_set_crypt(req, sg, sg,
 549                                                      template[i].ilen, iv);
 550                         ret = enc ?
 551                                 crypto_ablkcipher_encrypt(req) :
 552                                 crypto_ablkcipher_decrypt(req);
 553
 554                         switch (ret) {
 555                         case 0:
 556                                 break;
 557                         case -EINPROGRESS:
 558                         case -EBUSY:
 559                                 ret = wait_for_completion_interruptible(
 560                                         &result.completion);
 561                                 if (!ret && !((ret = result.err))) {
 562                                         INIT_COMPLETION(result.completion);
 563                                         break;
 564                                 }
 565                                 /* fall through */
 566                         default:
 567                                 printk("%s () failed err=%d\n", e, -ret);
 568                                 kfree(data);
 569                                 goto out;
 570                         }
 571
 572                         q = kmap(sg_page(&sg[0])) + sg[0].offset;
 573                         hexdump(q, template[i].rlen);
 574
 575                         printk("%s\n",
 576                                memcmp(q, template[i].result,
 577                                       template[i].rlen) ? "fail" : "pass");
 578                         kunmap(sg_page(&sg[0]));
 579                 }
 580                 kfree(data);
 581         }
 582
 583         printk("\ntesting %s %s across pages (chunking)\n", algo, e);
 584         memset(xbuf, 0, XBUFSIZE);
 585
 586         j = 0;
 587         for (i = 0; i < tcount; i++) {
 588
 589                 data = kzalloc(template[i].ilen, GFP_KERNEL);
 590                 if (!data)
 591                         continue;
 592
 593                 memcpy(data, template[i].input, template[i].ilen);
 594
 595                 if (template[i].iv)
 596                         memcpy(iv, template[i].iv, MAX_IVLEN);
 597                 else
 598                         memset(iv, 0, MAX_IVLEN);
 599
 600                 if (template[i].np) {
 601                         j++;
 602                         printk("test %u (%d bit key):\n",
 603                         j, template[i].klen * 8);
 604
 605                         crypto_ablkcipher_clear_flags(tfm, ~0);
 606                         if (template[i].wk)
 607                                 crypto_ablkcipher_set_flags(
 608                                         tfm, CRYPTO_TFM_REQ_WEAK_KEY);
 609
 610                         ret = crypto_ablkcipher_setkey(tfm, template[i].key,
 611                                                        template[i].klen);
 612                         if (ret) {
 613                                 printk("setkey() failed flags=%x\n",
 614                                                 crypto_ablkcipher_get_flags(tfm));
 615
 616                                 if (!template[i].fail) {
 617                                         kfree(data);
 618                                         goto out;
 619                                 }
 620                         }
 621
 622                         temp = 0;
 623                         sg_init_table(sg, template[i].np);
 624                         for (k = 0; k < template[i].np; k++) {
 625                                 memcpy(&xbuf[IDX[k]],
 626                                                 template[i].input + temp,
 627                                                 template[i].tap[k]);
 628                                 temp += template[i].tap[k];
 629                                 sg_set_buf(&sg[k], &xbuf[IDX[k]],
 630                                                 template[i].tap[k]);
 631                         }
 632
 633                         ablkcipher_request_set_crypt(req, sg, sg,
 634                                         template[i].ilen, iv);
 635
 636                         ret = enc ?
 637                                 crypto_ablkcipher_encrypt(req) :
 638                                 crypto_ablkcipher_decrypt(req);
 639
 640                         switch (ret) {
 641                         case 0:
 642                                 break;
 643                         case -EINPROGRESS:
 644                         case -EBUSY:
 645                                 ret = wait_for_completion_interruptible(
 646                                         &result.completion);
 647                                 if (!ret && !((ret = result.err))) {
 648                                         INIT_COMPLETION(result.completion);
 649                                         break;
 650                                 }
 651                                 /* fall through */
 652                         default:
 653                                 printk("%s () failed err=%d\n", e, -ret);
 654                                 goto out;
 655                         }
 656
 657                         temp = 0;
 658                         for (k = 0; k < template[i].np; k++) {
 659                                 printk("page %u\n", k);
 660                                 q = kmap(sg_page(&sg[k])) + sg[k].offset;
 661                                 hexdump(q, template[i].tap[k]);
 662                                 printk("%s\n",
 663                                         memcmp(q, template[i].result + temp,
 664                                                 template[i].tap[k]) ? "fail" :
 665                                         "pass");
 666                                 temp += template[i].tap[k];
 667                                 kunmap(sg_page(&sg[k]));
 668                         }
 669                 }
 670         }
 671 out:
 672         crypto_free_ablkcipher(tfm);
 673         ablkcipher_request_free(req);
 674 }
 675
 676 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, char *p,
 677                                int blen, int sec)
 678 {
 679         struct scatterlist sg[1];
 680         unsigned long start, end;
 681         int bcount;
 682         int ret;
 683
 684         sg_init_one(sg, p, blen);
 685
 686         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 687              time_before(jiffies, end); bcount++) {
 688                 if (enc)
 689                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 690                 else
 691                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 692
 693                 if (ret)
 694                         return ret;
 695         }
 696
 697         printk("%d operations in %d seconds (%ld bytes)\n",
 698                bcount, sec, (long)bcount * blen);
 699         return 0;
 700 }
 701
 702 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, char *p,
 703                               int blen)
 704 {
 705         struct scatterlist sg[1];
 706         unsigned long cycles = 0;
 707         int ret = 0;
 708         int i;
 709
 710         sg_init_one(sg, p, blen);
 711
 712         local_bh_disable();
 713         local_irq_disable();
 714
 715         /* Warm-up run. */
 716         for (i = 0; i < 4; i++) {
 717                 if (enc)
 718                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 719                 else
 720                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 721
 722                 if (ret)
 723                         goto out;
 724         }
 725
 726         /* The real thing. */
 727         for (i = 0; i < 8; i++) {
 728                 cycles_t start, end;
 729
 730                 start = get_cycles();
 731                 if (enc)
 732                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
 733                 else
 734                         ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
 735                 end = get_cycles();
 736
 737                 if (ret)
 738                         goto out;
 739
 740                 cycles += end - start;
 741         }
 742
 743 out:
 744         local_irq_enable();
 745         local_bh_enable();
 746
 747         if (ret == 0)
 748                 printk("1 operation in %lu cycles (%d bytes)\n",
 749                        (cycles + 4) / 8, blen);
 750
 751         return ret;
 752 }
 753
 754 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
 755
 756 static void test_cipher_speed(char *algo, int enc, unsigned int sec,
 757                               struct cipher_testvec *template,
 758                               unsigned int tcount, u8 *keysize)
 759 {
 760         unsigned int ret, i, j, iv_len;
 761         unsigned char *key, *p, iv[128];
 762         struct crypto_blkcipher *tfm;
 763         struct blkcipher_desc desc;
 764         const char *e;
 765         u32 *b_size;
 766
 767         if (enc == ENCRYPT)
 768                 e = "encryption";
 769         else
 770                 e = "decryption";
 771
 772         printk("\ntesting speed of %s %s\n", algo, e);
 773
 774         tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
 775
 776         if (IS_ERR(tfm)) {
 777                 printk("failed to load transform for %s: %ld\n", algo,
 778                        PTR_ERR(tfm));
 779                 return;
 780         }
 781         desc.tfm = tfm;
 782         desc.flags = 0;
 783
 784         i = 0;
 785         do {
 786
 787                 b_size = block_sizes;
 788                 do {
 789
 790                         if ((*keysize + *b_size) > TVMEMSIZE) {
 791                                 printk("template (%u) too big for tvmem (%u)\n",
 792                                                 *keysize + *b_size, TVMEMSIZE);
 793                                 goto out;
 794                         }
 795
 796                         printk("test %u (%d bit key, %d byte blocks): ", i,
 797                                         *keysize * 8, *b_size);
 798
 799                         memset(tvmem, 0xff, *keysize + *b_size);
 800
 801                         /* set key, plain text and IV */
 802                         key = (unsigned char *)tvmem;
 803                         for (j = 0; j < tcount; j++) {
 804                                 if (template[j].klen == *keysize) {
 805                                         key = template[j].key;
 806                                         break;
 807                                 }
 808                         }
 809                         p = (unsigned char *)tvmem + *keysize;
 810
 811                         ret = crypto_blkcipher_setkey(tfm, key, *keysize);
 812                         if (ret) {
 813                                 printk("setkey() failed flags=%x\n",
 814                                                 crypto_blkcipher_get_flags(tfm));
 815                                 goto out;
 816                         }
 817
 818                         iv_len = crypto_blkcipher_ivsize(tfm);
 819                         if (iv_len) {
 820                                 memset(&iv, 0xff, iv_len);
 821                                 crypto_blkcipher_set_iv(tfm, iv, iv_len);
 822                         }
 823
 824                         if (sec)
 825                                 ret = test_cipher_jiffies(&desc, enc, p, *b_size, sec);
 826                         else
 827                                 ret = test_cipher_cycles(&desc, enc, p, *b_size);
 828
 829                         if (ret) {
 830                                 printk("%s() failed flags=%x\n", e, desc.flags);
 831                                 break;
 832                         }
 833                         b_size++;
 834                         i++;
 835                 } while (*b_size);
 836                 keysize++;
 837         } while (*keysize);
 838
 839 out:
 840         crypto_free_blkcipher(tfm);
 841 }
 842
 843 static int test_hash_jiffies_digest(struct hash_desc *desc, char *p, int blen,
 844                                     char *out, int sec)
 845 {
 846         struct scatterlist sg[1];
 847         unsigned long start, end;
 848         int bcount;
 849         int ret;
 850
 851         sg_init_table(sg, 1);
 852
 853         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 854              time_before(jiffies, end); bcount++) {
 855                 sg_set_buf(sg, p, blen);
 856                 ret = crypto_hash_digest(desc, sg, blen, out);
 857                 if (ret)
 858                         return ret;
 859         }
 860
 861         printk("%6u opers/sec, %9lu bytes/sec\n",
 862                bcount / sec, ((long)bcount * blen) / sec);
 863
 864         return 0;
 865 }
 866
 867 static int test_hash_jiffies(struct hash_desc *desc, char *p, int blen,
 868                              int plen, char *out, int sec)
 869 {
 870         struct scatterlist sg[1];
 871         unsigned long start, end;
 872         int bcount, pcount;
 873         int ret;
 874
 875         if (plen == blen)
 876                 return test_hash_jiffies_digest(desc, p, blen, out, sec);
 877
 878         sg_init_table(sg, 1);
 879
 880         for (start = jiffies, end = start + sec * HZ, bcount = 0;
 881              time_before(jiffies, end); bcount++) {
 882                 ret = crypto_hash_init(desc);
 883                 if (ret)
 884                         return ret;
 885                 for (pcount = 0; pcount < blen; pcount += plen) {
 886                         sg_set_buf(sg, p + pcount, plen);
 887                         ret = crypto_hash_update(desc, sg, plen);
 888                         if (ret)
 889                                 return ret;
 890                 }
 891                 /* we assume there is enough space in 'out' for the result */
 892                 ret = crypto_hash_final(desc, out);
 893                 if (ret)
 894                         return ret;
 895         }
 896
 897         printk("%6u opers/sec, %9lu bytes/sec\n",
 898                bcount / sec, ((long)bcount * blen) / sec);
 899
 900         return 0;
 901 }
 902
 903 static int test_hash_cycles_digest(struct hash_desc *desc, char *p, int blen,
 904                                    char *out)
 905 {
 906         struct scatterlist sg[1];
 907         unsigned long cycles = 0;
 908         int i;
 909         int ret;
 910
 911         sg_init_table(sg, 1);
 912
 913         local_bh_disable();
 914         local_irq_disable();
 915
 916         /* Warm-up run. */
 917         for (i = 0; i < 4; i++) {
 918                 sg_set_buf(sg, p, blen);
 919                 ret = crypto_hash_digest(desc, sg, blen, out);
 920                 if (ret)
 921                         goto out;
 922         }
 923
 924         /* The real thing. */
 925         for (i = 0; i < 8; i++) {
 926                 cycles_t start, end;
 927
 928                 start = get_cycles();
 929
 930                 sg_set_buf(sg, p, blen);
 931                 ret = crypto_hash_digest(desc, sg, blen, out);
 932                 if (ret)
 933                         goto out;
 934
 935                 end = get_cycles();
 936
 937                 cycles += end - start;
 938         }
 939
 940 out:
 941         local_irq_enable();
 942         local_bh_enable();
 943
 944         if (ret)
 945                 return ret;
 946
 947         printk("%6lu cycles/operation, %4lu cycles/byte\n",
 948                cycles / 8, cycles / (8 * blen));
 949
 950         return 0;
 951 }
 952
 953 static int test_hash_cycles(struct hash_desc *desc, char *p, int blen,
 954                             int plen, char *out)
 955 {
 956         struct scatterlist sg[1];
 957         unsigned long cycles = 0;
 958         int i, pcount;
 959         int ret;
 960
 961         if (plen == blen)
 962                 return test_hash_cycles_digest(desc, p, blen, out);
 963
 964         sg_init_table(sg, 1);
 965
 966         local_bh_disable();
 967         local_irq_disable();
 968
 969         /* Warm-up run. */
 970         for (i = 0; i < 4; i++) {
 971                 ret = crypto_hash_init(desc);
 972                 if (ret)
 973                         goto out;
 974                 for (pcount = 0; pcount < blen; pcount += plen) {
 975                         sg_set_buf(sg, p + pcount, plen);
 976                         ret = crypto_hash_update(desc, sg, plen);
 977                         if (ret)
 978                                 goto out;
 979                 }
 980                 ret = crypto_hash_final(desc, out);
 981                 if (ret)
 982                         goto out;
 983         }
 984
 985         /* The real thing. */
 986         for (i = 0; i < 8; i++) {
 987                 cycles_t start, end;
 988
 989                 start = get_cycles();
 990
 991                 ret = crypto_hash_init(desc);
 992                 if (ret)
 993                         goto out;
 994                 for (pcount = 0; pcount < blen; pcount += plen) {
 995                         sg_set_buf(sg, p + pcount, plen);
 996                         ret = crypto_hash_update(desc, sg, plen);
 997                         if (ret)
 998                                 goto out;
 999                 }
1000                 ret = crypto_hash_final(desc, out);
1001                 if (ret)
1002                         goto out;
1003
1004                 end = get_cycles();
1005
1006                 cycles += end - start;
1007         }
1008
1009 out:
1010         local_irq_enable();
1011         local_bh_enable();
1012
1013         if (ret)
1014                 return ret;
1015
1016         printk("%6lu cycles/operation, %4lu cycles/byte\n",
1017                cycles / 8, cycles / (8 * blen));
1018
1019         return 0;
1020 }
1021
1022 static void test_hash_speed(char *algo, unsigned int sec,
1023                               struct hash_speed *speed)
1024 {
1025         struct crypto_hash *tfm;
1026         struct hash_desc desc;
1027         char output[1024];
1028         int i;
1029         int ret;
1030
1031         printk("\ntesting speed of %s\n", algo);
1032
1033         tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
1034
1035         if (IS_ERR(tfm)) {
1036                 printk("failed to load transform for %s: %ld\n", algo,
1037                        PTR_ERR(tfm));
1038                 return;
1039         }
1040
1041         desc.tfm = tfm;
1042         desc.flags = 0;
1043
1044         if (crypto_hash_digestsize(tfm) > sizeof(output)) {
1045                 printk("digestsize(%u) > outputbuffer(%zu)\n",
1046                        crypto_hash_digestsize(tfm), sizeof(output));
1047                 goto out;
1048         }
1049
1050         for (i = 0; speed[i].blen != 0; i++) {
1051                 if (speed[i].blen > TVMEMSIZE) {
1052                         printk("template (%u) too big for tvmem (%u)\n",
1053                                speed[i].blen, TVMEMSIZE);
1054                         goto out;
1055                 }
1056
1057                 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
1058                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
1059
1060                 memset(tvmem, 0xff, speed[i].blen);
1061
1062                 if (sec)
1063                         ret = test_hash_jiffies(&desc, tvmem, speed[i].blen,
1064                                                 speed[i].plen, output, sec);
1065                 else
1066                         ret = test_hash_cycles(&desc, tvmem, speed[i].blen,
1067                                                speed[i].plen, output);
1068
1069                 if (ret) {
1070                         printk("hashing failed ret=%d\n", ret);
1071                         break;
1072                 }
1073         }
1074
1075 out:
1076         crypto_free_hash(tfm);
1077 }
1078
1079 static void test_comp(char *algo, struct comp_testvec *ctemplate,
1080                        struct comp_testvec *dtemplate, int ctcount, int dtcount)
1081 {
1082         unsigned int i;
1083         char result[COMP_BUF_SIZE];
1084         struct crypto_comp *tfm;
1085         unsigned int tsize;
1086
1087         printk("\ntesting %s compression\n", algo);
1088
1089         tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC);
1090         if (IS_ERR(tfm)) {
1091                 printk("failed to load transform for %s\n", algo);
1092                 return;
1093         }
1094
1095         for (i = 0; i < ctcount; i++) {
1096                 int ilen, ret, dlen = COMP_BUF_SIZE;
1097
1098                 printk("test %u:\n", i + 1);
1099                 memset(result, 0, sizeof (result));
1100
1101                 ilen = ctemplate[i].inlen;
1102                 ret = crypto_comp_compress(tfm, ctemplate[i].input,
1103                                            ilen, result, &dlen);
1104                 if (ret) {
1105                         printk("fail: ret=%d\n", ret);
1106                         continue;
1107                 }
1108                 hexdump(result, dlen);
1109                 printk("%s (ratio %d:%d)\n",
1110                        memcmp(result, ctemplate[i].output, dlen) ? "fail" : "pass",
1111                        ilen, dlen);
1112         }
1113
1114         printk("\ntesting %s decompression\n", algo);
1115
1116         tsize = sizeof(struct comp_testvec);
1117         tsize *= dtcount;
1118         if (tsize > TVMEMSIZE) {
1119                 printk("template (%u) too big for tvmem (%u)\n", tsize,
1120                        TVMEMSIZE);
1121                 goto out;
1122         }
1123
1124         for (i = 0; i < dtcount; i++) {
1125                 int ilen, ret, dlen = COMP_BUF_SIZE;
1126
1127                 printk("test %u:\n", i + 1);
1128                 memset(result, 0, sizeof (result));
1129
1130                 ilen = dtemplate[i].inlen;
1131                 ret = crypto_comp_decompress(tfm, dtemplate[i].input,
1132                                              ilen, result, &dlen);
1133                 if (ret) {
1134                         printk("fail: ret=%d\n", ret);
1135                         continue;
1136                 }
1137                 hexdump(result, dlen);
1138                 printk("%s (ratio %d:%d)\n",
1139                        memcmp(result, dtemplate[i].output, dlen) ? "fail" : "pass",
1140                        ilen, dlen);
1141         }
1142 out:
1143         crypto_free_comp(tfm);
1144 }
1145
1146 static void test_available(void)
1147 {
1148         char **name = check;
1149
1150         while (*name) {
1151                 printk("alg %s ", *name);
1152                 printk(crypto_has_alg(*name, 0, 0) ?
1153                        "found\n" : "not found\n");
1154                 name++;
1155         }
1156 }
1157
1158 static void do_test(void)
1159 {
1160         switch (mode) {
1161
1162         case 0:
1163                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1164
1165                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1166
1167                 //DES
1168                 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1169                             DES_ENC_TEST_VECTORS);
1170                 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1171                             DES_DEC_TEST_VECTORS);
1172                 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1173                             DES_CBC_ENC_TEST_VECTORS);
1174                 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1175                             DES_CBC_DEC_TEST_VECTORS);
1176
1177                 //DES3_EDE
1178                 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1179                             DES3_EDE_ENC_TEST_VECTORS);
1180                 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1181                             DES3_EDE_DEC_TEST_VECTORS);
1182
1183                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1184
1185                 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1186
1187                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1188
1189                 //BLOWFISH
1190                 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1191                             BF_ENC_TEST_VECTORS);
1192                 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1193                             BF_DEC_TEST_VECTORS);
1194                 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1195                             BF_CBC_ENC_TEST_VECTORS);
1196                 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1197                             BF_CBC_DEC_TEST_VECTORS);
1198
1199                 //TWOFISH
1200                 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1201                             TF_ENC_TEST_VECTORS);
1202                 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1203                             TF_DEC_TEST_VECTORS);
1204                 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1205                             TF_CBC_ENC_TEST_VECTORS);
1206                 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1207                             TF_CBC_DEC_TEST_VECTORS);
1208
1209                 //SERPENT
1210                 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1211                             SERPENT_ENC_TEST_VECTORS);
1212                 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1213                             SERPENT_DEC_TEST_VECTORS);
1214
1215                 //TNEPRES
1216                 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1217                             TNEPRES_ENC_TEST_VECTORS);
1218                 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1219                             TNEPRES_DEC_TEST_VECTORS);
1220
1221                 //AES
1222                 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1223                             AES_ENC_TEST_VECTORS);
1224                 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1225                             AES_DEC_TEST_VECTORS);
1226                 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1227                             AES_CBC_ENC_TEST_VECTORS);
1228                 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1229                             AES_CBC_DEC_TEST_VECTORS);
1230                 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1231                             AES_LRW_ENC_TEST_VECTORS);
1232                 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1233                             AES_LRW_DEC_TEST_VECTORS);
1234                 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1235                             AES_XTS_ENC_TEST_VECTORS);
1236                 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1237                             AES_XTS_DEC_TEST_VECTORS);
1238                 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1239                             AES_CTR_ENC_TEST_VECTORS);
1240                 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1241                             AES_CTR_DEC_TEST_VECTORS);
1242                 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1243                           AES_GCM_ENC_TEST_VECTORS);
1244                 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1245                           AES_GCM_DEC_TEST_VECTORS);
1246                 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1247                           AES_CCM_ENC_TEST_VECTORS);
1248                 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1249                           AES_CCM_DEC_TEST_VECTORS);
1250
1251                 //CAST5
1252                 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1253                             CAST5_ENC_TEST_VECTORS);
1254                 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1255                             CAST5_DEC_TEST_VECTORS);
1256
1257                 //CAST6
1258                 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1259                             CAST6_ENC_TEST_VECTORS);
1260                 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1261                             CAST6_DEC_TEST_VECTORS);
1262
1263                 //ARC4
1264                 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1265                             ARC4_ENC_TEST_VECTORS);
1266                 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1267                             ARC4_DEC_TEST_VECTORS);
1268
1269                 //TEA
1270                 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1271                             TEA_ENC_TEST_VECTORS);
1272                 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1273                             TEA_DEC_TEST_VECTORS);
1274
1275
1276                 //XTEA
1277                 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1278                             XTEA_ENC_TEST_VECTORS);
1279                 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1280                             XTEA_DEC_TEST_VECTORS);
1281
1282                 //KHAZAD
1283                 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1284                             KHAZAD_ENC_TEST_VECTORS);
1285                 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1286                             KHAZAD_DEC_TEST_VECTORS);
1287
1288                 //ANUBIS
1289                 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1290                             ANUBIS_ENC_TEST_VECTORS);
1291                 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1292                             ANUBIS_DEC_TEST_VECTORS);
1293                 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1294                             ANUBIS_CBC_ENC_TEST_VECTORS);
1295                 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1296                             ANUBIS_CBC_ENC_TEST_VECTORS);
1297
1298                 //XETA
1299                 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1300                             XETA_ENC_TEST_VECTORS);
1301                 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1302                             XETA_DEC_TEST_VECTORS);
1303
1304                 //FCrypt
1305                 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1306                             FCRYPT_ENC_TEST_VECTORS);
1307                 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1308                             FCRYPT_DEC_TEST_VECTORS);
1309
1310                 //CAMELLIA
1311                 test_cipher("ecb(camellia)", ENCRYPT,
1312                             camellia_enc_tv_template,
1313                             CAMELLIA_ENC_TEST_VECTORS);
1314                 test_cipher("ecb(camellia)", DECRYPT,
1315                             camellia_dec_tv_template,
1316                             CAMELLIA_DEC_TEST_VECTORS);
1317                 test_cipher("cbc(camellia)", ENCRYPT,
1318                             camellia_cbc_enc_tv_template,
1319                             CAMELLIA_CBC_ENC_TEST_VECTORS);
1320                 test_cipher("cbc(camellia)", DECRYPT,
1321                             camellia_cbc_dec_tv_template,
1322                             CAMELLIA_CBC_DEC_TEST_VECTORS);
1323
1324                 //SEED
1325                 test_cipher("ecb(seed)", ENCRYPT, seed_enc_tv_template,
1326                             SEED_ENC_TEST_VECTORS);
1327                 test_cipher("ecb(seed)", DECRYPT, seed_dec_tv_template,
1328                             SEED_DEC_TEST_VECTORS);
1329
1330                 //CTS
1331                 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1332                             CTS_MODE_ENC_TEST_VECTORS);
1333                 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1334                             CTS_MODE_DEC_TEST_VECTORS);
1335
1336                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1337                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1338                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1339                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1340                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1341                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1342                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1343                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1344                 test_comp("deflate", deflate_comp_tv_template,
1345                           deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1346                           DEFLATE_DECOMP_TEST_VECTORS);
1347                 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1348                           LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1349                 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1350                 test_hash("hmac(md5)", hmac_md5_tv_template,
1351                           HMAC_MD5_TEST_VECTORS);
1352                 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1353                           HMAC_SHA1_TEST_VECTORS);
1354                 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1355                           HMAC_SHA224_TEST_VECTORS);
1356                 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1357                           HMAC_SHA256_TEST_VECTORS);
1358                 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1359                           HMAC_SHA384_TEST_VECTORS);
1360                 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1361                           HMAC_SHA512_TEST_VECTORS);
1362
1363                 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1364                           XCBC_AES_TEST_VECTORS);
1365
1366                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1367                 break;
1368
1369         case 1:
1370                 test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
1371                 break;
1372
1373         case 2:
1374                 test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
1375                 break;
1376
1377         case 3:
1378                 test_cipher("ecb(des)", ENCRYPT, des_enc_tv_template,
1379                             DES_ENC_TEST_VECTORS);
1380                 test_cipher("ecb(des)", DECRYPT, des_dec_tv_template,
1381                             DES_DEC_TEST_VECTORS);
1382                 test_cipher("cbc(des)", ENCRYPT, des_cbc_enc_tv_template,
1383                             DES_CBC_ENC_TEST_VECTORS);
1384                 test_cipher("cbc(des)", DECRYPT, des_cbc_dec_tv_template,
1385                             DES_CBC_DEC_TEST_VECTORS);
1386                 break;
1387
1388         case 4:
1389                 test_cipher("ecb(des3_ede)", ENCRYPT, des3_ede_enc_tv_template,
1390                             DES3_EDE_ENC_TEST_VECTORS);
1391                 test_cipher("ecb(des3_ede)", DECRYPT, des3_ede_dec_tv_template,
1392                             DES3_EDE_DEC_TEST_VECTORS);
1393                 break;
1394
1395         case 5:
1396                 test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
1397                 break;
1398
1399         case 6:
1400                 test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
1401                 break;
1402
1403         case 7:
1404                 test_cipher("ecb(blowfish)", ENCRYPT, bf_enc_tv_template,
1405                             BF_ENC_TEST_VECTORS);
1406                 test_cipher("ecb(blowfish)", DECRYPT, bf_dec_tv_template,
1407                             BF_DEC_TEST_VECTORS);
1408                 test_cipher("cbc(blowfish)", ENCRYPT, bf_cbc_enc_tv_template,
1409                             BF_CBC_ENC_TEST_VECTORS);
1410                 test_cipher("cbc(blowfish)", DECRYPT, bf_cbc_dec_tv_template,
1411                             BF_CBC_DEC_TEST_VECTORS);
1412                 break;
1413
1414         case 8:
1415                 test_cipher("ecb(twofish)", ENCRYPT, tf_enc_tv_template,
1416                             TF_ENC_TEST_VECTORS);
1417                 test_cipher("ecb(twofish)", DECRYPT, tf_dec_tv_template,
1418                             TF_DEC_TEST_VECTORS);
1419                 test_cipher("cbc(twofish)", ENCRYPT, tf_cbc_enc_tv_template,
1420                             TF_CBC_ENC_TEST_VECTORS);
1421                 test_cipher("cbc(twofish)", DECRYPT, tf_cbc_dec_tv_template,
1422                             TF_CBC_DEC_TEST_VECTORS);
1423                 break;
1424
1425         case 9:
1426                 test_cipher("ecb(serpent)", ENCRYPT, serpent_enc_tv_template,
1427                             SERPENT_ENC_TEST_VECTORS);
1428                 test_cipher("ecb(serpent)", DECRYPT, serpent_dec_tv_template,
1429                             SERPENT_DEC_TEST_VECTORS);
1430                 break;
1431
1432         case 10:
1433                 test_cipher("ecb(aes)", ENCRYPT, aes_enc_tv_template,
1434                             AES_ENC_TEST_VECTORS);
1435                 test_cipher("ecb(aes)", DECRYPT, aes_dec_tv_template,
1436                             AES_DEC_TEST_VECTORS);
1437                 test_cipher("cbc(aes)", ENCRYPT, aes_cbc_enc_tv_template,
1438                             AES_CBC_ENC_TEST_VECTORS);
1439                 test_cipher("cbc(aes)", DECRYPT, aes_cbc_dec_tv_template,
1440                             AES_CBC_DEC_TEST_VECTORS);
1441                 test_cipher("lrw(aes)", ENCRYPT, aes_lrw_enc_tv_template,
1442                             AES_LRW_ENC_TEST_VECTORS);
1443                 test_cipher("lrw(aes)", DECRYPT, aes_lrw_dec_tv_template,
1444                             AES_LRW_DEC_TEST_VECTORS);
1445                 test_cipher("xts(aes)", ENCRYPT, aes_xts_enc_tv_template,
1446                             AES_XTS_ENC_TEST_VECTORS);
1447                 test_cipher("xts(aes)", DECRYPT, aes_xts_dec_tv_template,
1448                             AES_XTS_DEC_TEST_VECTORS);
1449                 test_cipher("rfc3686(ctr(aes))", ENCRYPT, aes_ctr_enc_tv_template,
1450                             AES_CTR_ENC_TEST_VECTORS);
1451                 test_cipher("rfc3686(ctr(aes))", DECRYPT, aes_ctr_dec_tv_template,
1452                             AES_CTR_DEC_TEST_VECTORS);
1453                 break;
1454
1455         case 11:
1456                 test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
1457                 break;
1458
1459         case 12:
1460                 test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
1461                 break;
1462
1463         case 13:
1464                 test_comp("deflate", deflate_comp_tv_template,
1465                           deflate_decomp_tv_template, DEFLATE_COMP_TEST_VECTORS,
1466                           DEFLATE_DECOMP_TEST_VECTORS);
1467                 break;
1468
1469         case 14:
1470                 test_cipher("ecb(cast5)", ENCRYPT, cast5_enc_tv_template,
1471                             CAST5_ENC_TEST_VECTORS);
1472                 test_cipher("ecb(cast5)", DECRYPT, cast5_dec_tv_template,
1473                             CAST5_DEC_TEST_VECTORS);
1474                 break;
1475
1476         case 15:
1477                 test_cipher("ecb(cast6)", ENCRYPT, cast6_enc_tv_template,
1478                             CAST6_ENC_TEST_VECTORS);
1479                 test_cipher("ecb(cast6)", DECRYPT, cast6_dec_tv_template,
1480                             CAST6_DEC_TEST_VECTORS);
1481                 break;
1482
1483         case 16:
1484                 test_cipher("ecb(arc4)", ENCRYPT, arc4_enc_tv_template,
1485                             ARC4_ENC_TEST_VECTORS);
1486                 test_cipher("ecb(arc4)", DECRYPT, arc4_dec_tv_template,
1487                             ARC4_DEC_TEST_VECTORS);
1488                 break;
1489
1490         case 17:
1491                 test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
1492                 break;
1493
1494         case 18:
1495                 test_hash("crc32c", crc32c_tv_template, CRC32C_TEST_VECTORS);
1496                 break;
1497
1498         case 19:
1499                 test_cipher("ecb(tea)", ENCRYPT, tea_enc_tv_template,
1500                             TEA_ENC_TEST_VECTORS);
1501                 test_cipher("ecb(tea)", DECRYPT, tea_dec_tv_template,
1502                             TEA_DEC_TEST_VECTORS);
1503                 break;
1504
1505         case 20:
1506                 test_cipher("ecb(xtea)", ENCRYPT, xtea_enc_tv_template,
1507                             XTEA_ENC_TEST_VECTORS);
1508                 test_cipher("ecb(xtea)", DECRYPT, xtea_dec_tv_template,
1509                             XTEA_DEC_TEST_VECTORS);
1510                 break;
1511
1512         case 21:
1513                 test_cipher("ecb(khazad)", ENCRYPT, khazad_enc_tv_template,
1514                             KHAZAD_ENC_TEST_VECTORS);
1515                 test_cipher("ecb(khazad)", DECRYPT, khazad_dec_tv_template,
1516                             KHAZAD_DEC_TEST_VECTORS);
1517                 break;
1518
1519         case 22:
1520                 test_hash("wp512", wp512_tv_template, WP512_TEST_VECTORS);
1521                 break;
1522
1523         case 23:
1524                 test_hash("wp384", wp384_tv_template, WP384_TEST_VECTORS);
1525                 break;
1526
1527         case 24:
1528                 test_hash("wp256", wp256_tv_template, WP256_TEST_VECTORS);
1529                 break;
1530
1531         case 25:
1532                 test_cipher("ecb(tnepres)", ENCRYPT, tnepres_enc_tv_template,
1533                             TNEPRES_ENC_TEST_VECTORS);
1534                 test_cipher("ecb(tnepres)", DECRYPT, tnepres_dec_tv_template,
1535                             TNEPRES_DEC_TEST_VECTORS);
1536                 break;
1537
1538         case 26:
1539                 test_cipher("ecb(anubis)", ENCRYPT, anubis_enc_tv_template,
1540                             ANUBIS_ENC_TEST_VECTORS);
1541                 test_cipher("ecb(anubis)", DECRYPT, anubis_dec_tv_template,
1542                             ANUBIS_DEC_TEST_VECTORS);
1543                 test_cipher("cbc(anubis)", ENCRYPT, anubis_cbc_enc_tv_template,
1544                             ANUBIS_CBC_ENC_TEST_VECTORS);
1545                 test_cipher("cbc(anubis)", DECRYPT, anubis_cbc_dec_tv_template,
1546                             ANUBIS_CBC_ENC_TEST_VECTORS);
1547                 break;
1548
1549         case 27:
1550                 test_hash("tgr192", tgr192_tv_template, TGR192_TEST_VECTORS);
1551                 break;
1552
1553         case 28:
1554
1555                 test_hash("tgr160", tgr160_tv_template, TGR160_TEST_VECTORS);
1556                 break;
1557
1558         case 29:
1559                 test_hash("tgr128", tgr128_tv_template, TGR128_TEST_VECTORS);
1560                 break;
1561
1562         case 30:
1563                 test_cipher("ecb(xeta)", ENCRYPT, xeta_enc_tv_template,
1564                             XETA_ENC_TEST_VECTORS);
1565                 test_cipher("ecb(xeta)", DECRYPT, xeta_dec_tv_template,
1566                             XETA_DEC_TEST_VECTORS);
1567                 break;
1568
1569         case 31:
1570                 test_cipher("pcbc(fcrypt)", ENCRYPT, fcrypt_pcbc_enc_tv_template,
1571                             FCRYPT_ENC_TEST_VECTORS);
1572                 test_cipher("pcbc(fcrypt)", DECRYPT, fcrypt_pcbc_dec_tv_template,
1573                             FCRYPT_DEC_TEST_VECTORS);
1574                 break;
1575
1576         case 32:
1577                 test_cipher("ecb(camellia)", ENCRYPT,
1578                             camellia_enc_tv_template,
1579                             CAMELLIA_ENC_TEST_VECTORS);
1580                 test_cipher("ecb(camellia)", DECRYPT,
1581                             camellia_dec_tv_template,
1582                             CAMELLIA_DEC_TEST_VECTORS);
1583                 test_cipher("cbc(camellia)", ENCRYPT,
1584                             camellia_cbc_enc_tv_template,
1585                             CAMELLIA_CBC_ENC_TEST_VECTORS);
1586                 test_cipher("cbc(camellia)", DECRYPT,
1587                             camellia_cbc_dec_tv_template,
1588                             CAMELLIA_CBC_DEC_TEST_VECTORS);
1589                 break;
1590         case 33:
1591                 test_hash("sha224", sha224_tv_template, SHA224_TEST_VECTORS);
1592                 break;
1593
1594         case 34:
1595                 test_cipher("salsa20", ENCRYPT,
1596                             salsa20_stream_enc_tv_template,
1597                             SALSA20_STREAM_ENC_TEST_VECTORS);
1598                 break;
1599
1600         case 35:
1601                 test_aead("gcm(aes)", ENCRYPT, aes_gcm_enc_tv_template,
1602                           AES_GCM_ENC_TEST_VECTORS);
1603                 test_aead("gcm(aes)", DECRYPT, aes_gcm_dec_tv_template,
1604                           AES_GCM_DEC_TEST_VECTORS);
1605                 break;
1606
1607         case 36:
1608                 test_comp("lzo", lzo_comp_tv_template, lzo_decomp_tv_template,
1609                           LZO_COMP_TEST_VECTORS, LZO_DECOMP_TEST_VECTORS);
1610                 break;
1611
1612         case 37:
1613                 test_aead("ccm(aes)", ENCRYPT, aes_ccm_enc_tv_template,
1614                           AES_CCM_ENC_TEST_VECTORS);
1615                 test_aead("ccm(aes)", DECRYPT, aes_ccm_dec_tv_template,
1616                           AES_CCM_DEC_TEST_VECTORS);
1617                 break;
1618
1619         case 38:
1620                 test_cipher("cts(cbc(aes))", ENCRYPT, cts_mode_enc_tv_template,
1621                             CTS_MODE_ENC_TEST_VECTORS);
1622                 test_cipher("cts(cbc(aes))", DECRYPT, cts_mode_dec_tv_template,
1623                             CTS_MODE_DEC_TEST_VECTORS);
1624                 break;
1625
1626         case 100:
1627                 test_hash("hmac(md5)", hmac_md5_tv_template,
1628                           HMAC_MD5_TEST_VECTORS);
1629                 break;
1630
1631         case 101:
1632                 test_hash("hmac(sha1)", hmac_sha1_tv_template,
1633                           HMAC_SHA1_TEST_VECTORS);
1634                 break;
1635
1636         case 102:
1637                 test_hash("hmac(sha256)", hmac_sha256_tv_template,
1638                           HMAC_SHA256_TEST_VECTORS);
1639                 break;
1640
1641         case 103:
1642                 test_hash("hmac(sha384)", hmac_sha384_tv_template,
1643                           HMAC_SHA384_TEST_VECTORS);
1644                 break;
1645
1646         case 104:
1647                 test_hash("hmac(sha512)", hmac_sha512_tv_template,
1648                           HMAC_SHA512_TEST_VECTORS);
1649                 break;
1650
1651         case 105:
1652                 test_hash("hmac(sha224)", hmac_sha224_tv_template,
1653                           HMAC_SHA224_TEST_VECTORS);
1654                 break;
1655
1656         case 106:
1657                 test_hash("xcbc(aes)", aes_xcbc128_tv_template,
1658                           XCBC_AES_TEST_VECTORS);
1659                 break;
1660
1661         case 200:
1662                 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
1663                                 speed_template_16_24_32);
1664                 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
1665                                 speed_template_16_24_32);
1666                 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
1667                                 speed_template_16_24_32);
1668                 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
1669                                 speed_template_16_24_32);
1670                 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
1671                                 speed_template_32_40_48);
1672                 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
1673                                 speed_template_32_40_48);
1674                 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
1675                                 speed_template_32_48_64);
1676                 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
1677                                 speed_template_32_48_64);
1678                 break;
1679
1680         case 201:
1681                 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
1682                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1683                                 speed_template_24);
1684                 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
1685                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1686                                 speed_template_24);
1687                 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
1688                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1689                                 speed_template_24);
1690                 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
1691                                 des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS,
1692                                 speed_template_24);
1693                 break;
1694
1695         case 202:
1696                 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
1697                                 speed_template_16_24_32);
1698                 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
1699                                 speed_template_16_24_32);
1700                 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
1701                                 speed_template_16_24_32);
1702                 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
1703                                 speed_template_16_24_32);
1704                 break;
1705
1706         case 203:
1707                 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
1708                                   speed_template_8_32);
1709                 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
1710                                   speed_template_8_32);
1711                 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
1712                                   speed_template_8_32);
1713                 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
1714                                   speed_template_8_32);
1715                 break;
1716
1717         case 204:
1718                 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
1719                                   speed_template_8);
1720                 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
1721                                   speed_template_8);
1722                 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
1723                                   speed_template_8);
1724                 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
1725                                   speed_template_8);
1726                 break;
1727
1728         case 205:
1729                 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
1730                                 speed_template_16_24_32);
1731                 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
1732                                 speed_template_16_24_32);
1733                 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
1734                                 speed_template_16_24_32);
1735                 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
1736                                 speed_template_16_24_32);
1737                 break;
1738
1739         case 206:
1740                 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
1741                                   speed_template_16_32);
1742                 break;
1743
1744         case 300:
1745                 /* fall through */
1746
1747         case 301:
1748                 test_hash_speed("md4", sec, generic_hash_speed_template);
1749                 if (mode > 300 && mode < 400) break;
1750
1751         case 302:
1752                 test_hash_speed("md5", sec, generic_hash_speed_template);
1753                 if (mode > 300 && mode < 400) break;
1754
1755         case 303:
1756                 test_hash_speed("sha1", sec, generic_hash_speed_template);
1757                 if (mode > 300 && mode < 400) break;
1758
1759         case 304:
1760                 test_hash_speed("sha256", sec, generic_hash_speed_template);
1761                 if (mode > 300 && mode < 400) break;
1762
1763         case 305:
1764                 test_hash_speed("sha384", sec, generic_hash_speed_template);
1765                 if (mode > 300 && mode < 400) break;
1766
1767         case 306:
1768                 test_hash_speed("sha512", sec, generic_hash_speed_template);
1769                 if (mode > 300 && mode < 400) break;
1770
1771         case 307:
1772                 test_hash_speed("wp256", sec, generic_hash_speed_template);
1773                 if (mode > 300 && mode < 400) break;
1774
1775         case 308:
1776                 test_hash_speed("wp384", sec, generic_hash_speed_template);
1777                 if (mode > 300 && mode < 400) break;
1778
1779         case 309:
1780                 test_hash_speed("wp512", sec, generic_hash_speed_template);
1781                 if (mode > 300 && mode < 400) break;
1782
1783         case 310:
1784                 test_hash_speed("tgr128", sec, generic_hash_speed_template);
1785                 if (mode > 300 && mode < 400) break;
1786
1787         case 311:
1788                 test_hash_speed("tgr160", sec, generic_hash_speed_template);
1789                 if (mode > 300 && mode < 400) break;
1790
1791         case 312:
1792                 test_hash_speed("tgr192", sec, generic_hash_speed_template);
1793                 if (mode > 300 && mode < 400) break;
1794
1795         case 313:
1796                 test_hash_speed("sha224", sec, generic_hash_speed_template);
1797                 if (mode > 300 && mode < 400) break;
1798
1799         case 399:
1800                 break;
1801
1802         case 1000:
1803                 test_available();
1804                 break;
1805
1806         default:
1807                 /* useful for debugging */
1808                 printk("not testing anything\n");
1809                 break;
1810         }
1811 }
1812
1813 static int __init tcrypt_mod_init(void)
1814 {
1815         int err = -ENOMEM;
1816
1817         tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
1818         if (tvmem == NULL)
1819                 return err;
1820
1821         xbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1822         if (xbuf == NULL)
1823                 goto err_free_tv;
1824
1825         axbuf = kmalloc(XBUFSIZE, GFP_KERNEL);
1826         if (axbuf == NULL)
1827                 goto err_free_xbuf;
1828
1829         do_test();
1830
1831         /* We intentionaly return -EAGAIN to prevent keeping
1832          * the module. It does all its work from init()
1833          * and doesn't offer any runtime functionality
1834          * => we don't need it in the memory, do we?
1835          *                                        -- mludvig
1836          */
1837         err = -EAGAIN;
1838
1839         kfree(axbuf);
1840  err_free_xbuf:
1841         kfree(xbuf);
1842  err_free_tv:
1843         kfree(tvmem);
1844
1845         return err;
1846 }
1847
1848 /*
1849  * If an init function is provided, an exit function must also be provided
1850  * to allow module unload.
1851  */
1852 static void __exit tcrypt_mod_fini(void) { }
1853
1854 module_init(tcrypt_mod_init);
1855 module_exit(tcrypt_mod_fini);
1856
1857 module_param(mode, int, 0);
1858 module_param(sec, uint, 0);
1859 MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
1860                       "(defaults to zero which uses CPU cycles instead)");
1861
1862 MODULE_LICENSE("GPL");
1863 MODULE_DESCRIPTION("Quick & dirty crypto testing module");
1864 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");