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 */ 17 18 #include <crypto/hash.h> 19 #include <linux/err.h> 20 #include <linux/init.h> 21 #include <linux/module.h> 22 #include <linux/slab.h> 23 #include <linux/scatterlist.h> 24 #include <linux/string.h> 25 #include <linux/moduleparam.h> 26 #include <linux/jiffies.h> 27 #include <linux/timex.h> 28 #include <linux/interrupt.h> 29 #include "tcrypt.h" 30 31 /* 32 * Need slab memory for testing (size in number of pages). 33 */ 34 #define TVMEMSIZE 4 35 36 /* 37 * Used by test_cipher_speed() 38 */ 39 #define ENCRYPT 1 40 #define DECRYPT 0 41 42 /* 43 * Used by test_cipher_speed() 44 */ 45 static unsigned int sec; 46 47 static int mode; 48 static char *tvmem[TVMEMSIZE]; 49 50 static char *check[] = { 51 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256", 52 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes", 53 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 54 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt", 55 "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320", 56 "lzo", "cts", "zlib", NULL 57 }; 58 59 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, 60 struct scatterlist *sg, int blen, int sec) 61 { 62 unsigned long start, end; 63 int bcount; 64 int ret; 65 66 for (start = jiffies, end = start + sec * HZ, bcount = 0; 67 time_before(jiffies, end); bcount++) { 68 if (enc) 69 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 70 else 71 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 72 73 if (ret) 74 return ret; 75 } 76 77 printk("%d operations in %d seconds (%ld bytes)\n", 78 bcount, sec, (long)bcount * blen); 79 return 0; 80 } 81 82 static int test_cipher_cycles(struct blkcipher_desc *desc, int enc, 83 struct scatterlist *sg, int blen) 84 { 85 unsigned long cycles = 0; 86 int ret = 0; 87 int i; 88 89 local_bh_disable(); 90 local_irq_disable(); 91 92 /* Warm-up run. */ 93 for (i = 0; i < 4; i++) { 94 if (enc) 95 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 96 else 97 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 98 99 if (ret) 100 goto out; 101 } 102 103 /* The real thing. */ 104 for (i = 0; i < 8; i++) { 105 cycles_t start, end; 106 107 start = get_cycles(); 108 if (enc) 109 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen); 110 else 111 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen); 112 end = get_cycles(); 113 114 if (ret) 115 goto out; 116 117 cycles += end - start; 118 } 119 120 out: 121 local_irq_enable(); 122 local_bh_enable(); 123 124 if (ret == 0) 125 printk("1 operation in %lu cycles (%d bytes)\n", 126 (cycles + 4) / 8, blen); 127 128 return ret; 129 } 130 131 static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 }; 132 133 static void test_cipher_speed(const char *algo, int enc, unsigned int sec, 134 struct cipher_speed_template *template, 135 unsigned int tcount, u8 *keysize) 136 { 137 unsigned int ret, i, j, iv_len; 138 const char *key, iv[128]; 139 struct crypto_blkcipher *tfm; 140 struct blkcipher_desc desc; 141 const char *e; 142 u32 *b_size; 143 144 if (enc == ENCRYPT) 145 e = "encryption"; 146 else 147 e = "decryption"; 148 149 printk("\ntesting speed of %s %s\n", algo, e); 150 151 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC); 152 153 if (IS_ERR(tfm)) { 154 printk("failed to load transform for %s: %ld\n", algo, 155 PTR_ERR(tfm)); 156 return; 157 } 158 desc.tfm = tfm; 159 desc.flags = 0; 160 161 i = 0; 162 do { 163 164 b_size = block_sizes; 165 do { 166 struct scatterlist sg[TVMEMSIZE]; 167 168 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) { 169 printk("template (%u) too big for " 170 "tvmem (%lu)\n", *keysize + *b_size, 171 TVMEMSIZE * PAGE_SIZE); 172 goto out; 173 } 174 175 printk("test %u (%d bit key, %d byte blocks): ", i, 176 *keysize * 8, *b_size); 177 178 memset(tvmem[0], 0xff, PAGE_SIZE); 179 180 /* set key, plain text and IV */ 181 key = tvmem[0]; 182 for (j = 0; j < tcount; j++) { 183 if (template[j].klen == *keysize) { 184 key = template[j].key; 185 break; 186 } 187 } 188 189 ret = crypto_blkcipher_setkey(tfm, key, *keysize); 190 if (ret) { 191 printk("setkey() failed flags=%x\n", 192 crypto_blkcipher_get_flags(tfm)); 193 goto out; 194 } 195 196 sg_init_table(sg, TVMEMSIZE); 197 sg_set_buf(sg, tvmem[0] + *keysize, 198 PAGE_SIZE - *keysize); 199 for (j = 1; j < TVMEMSIZE; j++) { 200 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE); 201 memset (tvmem[j], 0xff, PAGE_SIZE); 202 } 203 204 iv_len = crypto_blkcipher_ivsize(tfm); 205 if (iv_len) { 206 memset(&iv, 0xff, iv_len); 207 crypto_blkcipher_set_iv(tfm, iv, iv_len); 208 } 209 210 if (sec) 211 ret = test_cipher_jiffies(&desc, enc, sg, 212 *b_size, sec); 213 else 214 ret = test_cipher_cycles(&desc, enc, sg, 215 *b_size); 216 217 if (ret) { 218 printk("%s() failed flags=%x\n", e, desc.flags); 219 break; 220 } 221 b_size++; 222 i++; 223 } while (*b_size); 224 keysize++; 225 } while (*keysize); 226 227 out: 228 crypto_free_blkcipher(tfm); 229 } 230 231 static int test_hash_jiffies_digest(struct hash_desc *desc, 232 struct scatterlist *sg, int blen, 233 char *out, int sec) 234 { 235 unsigned long start, end; 236 int bcount; 237 int ret; 238 239 for (start = jiffies, end = start + sec * HZ, bcount = 0; 240 time_before(jiffies, end); bcount++) { 241 ret = crypto_hash_digest(desc, sg, blen, out); 242 if (ret) 243 return ret; 244 } 245 246 printk("%6u opers/sec, %9lu bytes/sec\n", 247 bcount / sec, ((long)bcount * blen) / sec); 248 249 return 0; 250 } 251 252 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg, 253 int blen, int plen, char *out, int sec) 254 { 255 unsigned long start, end; 256 int bcount, pcount; 257 int ret; 258 259 if (plen == blen) 260 return test_hash_jiffies_digest(desc, sg, blen, out, sec); 261 262 for (start = jiffies, end = start + sec * HZ, bcount = 0; 263 time_before(jiffies, end); bcount++) { 264 ret = crypto_hash_init(desc); 265 if (ret) 266 return ret; 267 for (pcount = 0; pcount < blen; pcount += plen) { 268 ret = crypto_hash_update(desc, sg, plen); 269 if (ret) 270 return ret; 271 } 272 /* we assume there is enough space in 'out' for the result */ 273 ret = crypto_hash_final(desc, out); 274 if (ret) 275 return ret; 276 } 277 278 printk("%6u opers/sec, %9lu bytes/sec\n", 279 bcount / sec, ((long)bcount * blen) / sec); 280 281 return 0; 282 } 283 284 static int test_hash_cycles_digest(struct hash_desc *desc, 285 struct scatterlist *sg, int blen, char *out) 286 { 287 unsigned long cycles = 0; 288 int i; 289 int ret; 290 291 local_bh_disable(); 292 local_irq_disable(); 293 294 /* Warm-up run. */ 295 for (i = 0; i < 4; i++) { 296 ret = crypto_hash_digest(desc, sg, blen, out); 297 if (ret) 298 goto out; 299 } 300 301 /* The real thing. */ 302 for (i = 0; i < 8; i++) { 303 cycles_t start, end; 304 305 start = get_cycles(); 306 307 ret = crypto_hash_digest(desc, sg, blen, out); 308 if (ret) 309 goto out; 310 311 end = get_cycles(); 312 313 cycles += end - start; 314 } 315 316 out: 317 local_irq_enable(); 318 local_bh_enable(); 319 320 if (ret) 321 return ret; 322 323 printk("%6lu cycles/operation, %4lu cycles/byte\n", 324 cycles / 8, cycles / (8 * blen)); 325 326 return 0; 327 } 328 329 static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg, 330 int blen, int plen, char *out) 331 { 332 unsigned long cycles = 0; 333 int i, pcount; 334 int ret; 335 336 if (plen == blen) 337 return test_hash_cycles_digest(desc, sg, blen, out); 338 339 local_bh_disable(); 340 local_irq_disable(); 341 342 /* Warm-up run. */ 343 for (i = 0; i < 4; i++) { 344 ret = crypto_hash_init(desc); 345 if (ret) 346 goto out; 347 for (pcount = 0; pcount < blen; pcount += plen) { 348 ret = crypto_hash_update(desc, sg, plen); 349 if (ret) 350 goto out; 351 } 352 ret = crypto_hash_final(desc, out); 353 if (ret) 354 goto out; 355 } 356 357 /* The real thing. */ 358 for (i = 0; i < 8; i++) { 359 cycles_t start, end; 360 361 start = get_cycles(); 362 363 ret = crypto_hash_init(desc); 364 if (ret) 365 goto out; 366 for (pcount = 0; pcount < blen; pcount += plen) { 367 ret = crypto_hash_update(desc, sg, plen); 368 if (ret) 369 goto out; 370 } 371 ret = crypto_hash_final(desc, out); 372 if (ret) 373 goto out; 374 375 end = get_cycles(); 376 377 cycles += end - start; 378 } 379 380 out: 381 local_irq_enable(); 382 local_bh_enable(); 383 384 if (ret) 385 return ret; 386 387 printk("%6lu cycles/operation, %4lu cycles/byte\n", 388 cycles / 8, cycles / (8 * blen)); 389 390 return 0; 391 } 392 393 static void test_hash_speed(const char *algo, unsigned int sec, 394 struct hash_speed *speed) 395 { 396 struct scatterlist sg[TVMEMSIZE]; 397 struct crypto_hash *tfm; 398 struct hash_desc desc; 399 char output[1024]; 400 int i; 401 int ret; 402 403 printk("\ntesting speed of %s\n", algo); 404 405 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC); 406 407 if (IS_ERR(tfm)) { 408 printk("failed to load transform for %s: %ld\n", algo, 409 PTR_ERR(tfm)); 410 return; 411 } 412 413 desc.tfm = tfm; 414 desc.flags = 0; 415 416 if (crypto_hash_digestsize(tfm) > sizeof(output)) { 417 printk("digestsize(%u) > outputbuffer(%zu)\n", 418 crypto_hash_digestsize(tfm), sizeof(output)); 419 goto out; 420 } 421 422 sg_init_table(sg, TVMEMSIZE); 423 for (i = 0; i < TVMEMSIZE; i++) { 424 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE); 425 memset(tvmem[i], 0xff, PAGE_SIZE); 426 } 427 428 for (i = 0; speed[i].blen != 0; i++) { 429 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) { 430 printk("template (%u) too big for tvmem (%lu)\n", 431 speed[i].blen, TVMEMSIZE * PAGE_SIZE); 432 goto out; 433 } 434 435 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ", 436 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); 437 438 if (sec) 439 ret = test_hash_jiffies(&desc, sg, speed[i].blen, 440 speed[i].plen, output, sec); 441 else 442 ret = test_hash_cycles(&desc, sg, speed[i].blen, 443 speed[i].plen, output); 444 445 if (ret) { 446 printk("hashing failed ret=%d\n", ret); 447 break; 448 } 449 } 450 451 out: 452 crypto_free_hash(tfm); 453 } 454 455 static void test_available(void) 456 { 457 char **name = check; 458 459 while (*name) { 460 printk("alg %s ", *name); 461 printk(crypto_has_alg(*name, 0, 0) ? 462 "found\n" : "not found\n"); 463 name++; 464 } 465 } 466 467 static inline int tcrypt_test(const char *alg) 468 { 469 return alg_test(alg, alg, 0, 0); 470 } 471 472 static void do_test(int m) 473 { 474 int i; 475 476 switch (m) { 477 case 0: 478 for (i = 1; i < 200; i++) 479 do_test(i); 480 break; 481 482 case 1: 483 tcrypt_test("md5"); 484 break; 485 486 case 2: 487 tcrypt_test("sha1"); 488 break; 489 490 case 3: 491 tcrypt_test("ecb(des)"); 492 tcrypt_test("cbc(des)"); 493 break; 494 495 case 4: 496 tcrypt_test("ecb(des3_ede)"); 497 tcrypt_test("cbc(des3_ede)"); 498 break; 499 500 case 5: 501 tcrypt_test("md4"); 502 break; 503 504 case 6: 505 tcrypt_test("sha256"); 506 break; 507 508 case 7: 509 tcrypt_test("ecb(blowfish)"); 510 tcrypt_test("cbc(blowfish)"); 511 break; 512 513 case 8: 514 tcrypt_test("ecb(twofish)"); 515 tcrypt_test("cbc(twofish)"); 516 break; 517 518 case 9: 519 tcrypt_test("ecb(serpent)"); 520 break; 521 522 case 10: 523 tcrypt_test("ecb(aes)"); 524 tcrypt_test("cbc(aes)"); 525 tcrypt_test("lrw(aes)"); 526 tcrypt_test("xts(aes)"); 527 tcrypt_test("rfc3686(ctr(aes))"); 528 break; 529 530 case 11: 531 tcrypt_test("sha384"); 532 break; 533 534 case 12: 535 tcrypt_test("sha512"); 536 break; 537 538 case 13: 539 tcrypt_test("deflate"); 540 break; 541 542 case 14: 543 tcrypt_test("ecb(cast5)"); 544 break; 545 546 case 15: 547 tcrypt_test("ecb(cast6)"); 548 break; 549 550 case 16: 551 tcrypt_test("ecb(arc4)"); 552 break; 553 554 case 17: 555 tcrypt_test("michael_mic"); 556 break; 557 558 case 18: 559 tcrypt_test("crc32c"); 560 break; 561 562 case 19: 563 tcrypt_test("ecb(tea)"); 564 break; 565 566 case 20: 567 tcrypt_test("ecb(xtea)"); 568 break; 569 570 case 21: 571 tcrypt_test("ecb(khazad)"); 572 break; 573 574 case 22: 575 tcrypt_test("wp512"); 576 break; 577 578 case 23: 579 tcrypt_test("wp384"); 580 break; 581 582 case 24: 583 tcrypt_test("wp256"); 584 break; 585 586 case 25: 587 tcrypt_test("ecb(tnepres)"); 588 break; 589 590 case 26: 591 tcrypt_test("ecb(anubis)"); 592 tcrypt_test("cbc(anubis)"); 593 break; 594 595 case 27: 596 tcrypt_test("tgr192"); 597 break; 598 599 case 28: 600 601 tcrypt_test("tgr160"); 602 break; 603 604 case 29: 605 tcrypt_test("tgr128"); 606 break; 607 608 case 30: 609 tcrypt_test("ecb(xeta)"); 610 break; 611 612 case 31: 613 tcrypt_test("pcbc(fcrypt)"); 614 break; 615 616 case 32: 617 tcrypt_test("ecb(camellia)"); 618 tcrypt_test("cbc(camellia)"); 619 break; 620 case 33: 621 tcrypt_test("sha224"); 622 break; 623 624 case 34: 625 tcrypt_test("salsa20"); 626 break; 627 628 case 35: 629 tcrypt_test("gcm(aes)"); 630 break; 631 632 case 36: 633 tcrypt_test("lzo"); 634 break; 635 636 case 37: 637 tcrypt_test("ccm(aes)"); 638 break; 639 640 case 38: 641 tcrypt_test("cts(cbc(aes))"); 642 break; 643 644 case 39: 645 tcrypt_test("rmd128"); 646 break; 647 648 case 40: 649 tcrypt_test("rmd160"); 650 break; 651 652 case 41: 653 tcrypt_test("rmd256"); 654 break; 655 656 case 42: 657 tcrypt_test("rmd320"); 658 break; 659 660 case 43: 661 tcrypt_test("ecb(seed)"); 662 break; 663 664 case 44: 665 tcrypt_test("zlib"); 666 break; 667 668 case 100: 669 tcrypt_test("hmac(md5)"); 670 break; 671 672 case 101: 673 tcrypt_test("hmac(sha1)"); 674 break; 675 676 case 102: 677 tcrypt_test("hmac(sha256)"); 678 break; 679 680 case 103: 681 tcrypt_test("hmac(sha384)"); 682 break; 683 684 case 104: 685 tcrypt_test("hmac(sha512)"); 686 break; 687 688 case 105: 689 tcrypt_test("hmac(sha224)"); 690 break; 691 692 case 106: 693 tcrypt_test("xcbc(aes)"); 694 break; 695 696 case 107: 697 tcrypt_test("hmac(rmd128)"); 698 break; 699 700 case 108: 701 tcrypt_test("hmac(rmd160)"); 702 break; 703 704 case 200: 705 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0, 706 speed_template_16_24_32); 707 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0, 708 speed_template_16_24_32); 709 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0, 710 speed_template_16_24_32); 711 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0, 712 speed_template_16_24_32); 713 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0, 714 speed_template_32_40_48); 715 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0, 716 speed_template_32_40_48); 717 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0, 718 speed_template_32_48_64); 719 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0, 720 speed_template_32_48_64); 721 break; 722 723 case 201: 724 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec, 725 des3_speed_template, DES3_SPEED_VECTORS, 726 speed_template_24); 727 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec, 728 des3_speed_template, DES3_SPEED_VECTORS, 729 speed_template_24); 730 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec, 731 des3_speed_template, DES3_SPEED_VECTORS, 732 speed_template_24); 733 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec, 734 des3_speed_template, DES3_SPEED_VECTORS, 735 speed_template_24); 736 break; 737 738 case 202: 739 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0, 740 speed_template_16_24_32); 741 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0, 742 speed_template_16_24_32); 743 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0, 744 speed_template_16_24_32); 745 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0, 746 speed_template_16_24_32); 747 break; 748 749 case 203: 750 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0, 751 speed_template_8_32); 752 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0, 753 speed_template_8_32); 754 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0, 755 speed_template_8_32); 756 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0, 757 speed_template_8_32); 758 break; 759 760 case 204: 761 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0, 762 speed_template_8); 763 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0, 764 speed_template_8); 765 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0, 766 speed_template_8); 767 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0, 768 speed_template_8); 769 break; 770 771 case 205: 772 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0, 773 speed_template_16_24_32); 774 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0, 775 speed_template_16_24_32); 776 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0, 777 speed_template_16_24_32); 778 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0, 779 speed_template_16_24_32); 780 break; 781 782 case 206: 783 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0, 784 speed_template_16_32); 785 break; 786 787 case 300: 788 /* fall through */ 789 790 case 301: 791 test_hash_speed("md4", sec, generic_hash_speed_template); 792 if (mode > 300 && mode < 400) break; 793 794 case 302: 795 test_hash_speed("md5", sec, generic_hash_speed_template); 796 if (mode > 300 && mode < 400) break; 797 798 case 303: 799 test_hash_speed("sha1", sec, generic_hash_speed_template); 800 if (mode > 300 && mode < 400) break; 801 802 case 304: 803 test_hash_speed("sha256", sec, generic_hash_speed_template); 804 if (mode > 300 && mode < 400) break; 805 806 case 305: 807 test_hash_speed("sha384", sec, generic_hash_speed_template); 808 if (mode > 300 && mode < 400) break; 809 810 case 306: 811 test_hash_speed("sha512", sec, generic_hash_speed_template); 812 if (mode > 300 && mode < 400) break; 813 814 case 307: 815 test_hash_speed("wp256", sec, generic_hash_speed_template); 816 if (mode > 300 && mode < 400) break; 817 818 case 308: 819 test_hash_speed("wp384", sec, generic_hash_speed_template); 820 if (mode > 300 && mode < 400) break; 821 822 case 309: 823 test_hash_speed("wp512", sec, generic_hash_speed_template); 824 if (mode > 300 && mode < 400) break; 825 826 case 310: 827 test_hash_speed("tgr128", sec, generic_hash_speed_template); 828 if (mode > 300 && mode < 400) break; 829 830 case 311: 831 test_hash_speed("tgr160", sec, generic_hash_speed_template); 832 if (mode > 300 && mode < 400) break; 833 834 case 312: 835 test_hash_speed("tgr192", sec, generic_hash_speed_template); 836 if (mode > 300 && mode < 400) break; 837 838 case 313: 839 test_hash_speed("sha224", sec, generic_hash_speed_template); 840 if (mode > 300 && mode < 400) break; 841 842 case 314: 843 test_hash_speed("rmd128", sec, generic_hash_speed_template); 844 if (mode > 300 && mode < 400) break; 845 846 case 315: 847 test_hash_speed("rmd160", sec, generic_hash_speed_template); 848 if (mode > 300 && mode < 400) break; 849 850 case 316: 851 test_hash_speed("rmd256", sec, generic_hash_speed_template); 852 if (mode > 300 && mode < 400) break; 853 854 case 317: 855 test_hash_speed("rmd320", sec, generic_hash_speed_template); 856 if (mode > 300 && mode < 400) break; 857 858 case 399: 859 break; 860 861 case 1000: 862 test_available(); 863 break; 864 } 865 } 866 867 static int __init tcrypt_mod_init(void) 868 { 869 int err = -ENOMEM; 870 int i; 871 872 for (i = 0; i < TVMEMSIZE; i++) { 873 tvmem[i] = (void *)__get_free_page(GFP_KERNEL); 874 if (!tvmem[i]) 875 goto err_free_tv; 876 } 877 878 do_test(mode); 879 880 /* We intentionaly return -EAGAIN to prevent keeping 881 * the module. It does all its work from init() 882 * and doesn't offer any runtime functionality 883 * => we don't need it in the memory, do we? 884 * -- mludvig 885 */ 886 err = -EAGAIN; 887 888 err_free_tv: 889 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++) 890 free_page((unsigned long)tvmem[i]); 891 892 return err; 893 } 894 895 /* 896 * If an init function is provided, an exit function must also be provided 897 * to allow module unload. 898 */ 899 static void __exit tcrypt_mod_fini(void) { } 900 901 module_init(tcrypt_mod_init); 902 module_exit(tcrypt_mod_fini); 903 904 module_param(mode, int, 0); 905 module_param(sec, uint, 0); 906 MODULE_PARM_DESC(sec, "Length in seconds of speed tests " 907 "(defaults to zero which uses CPU cycles instead)"); 908 909 MODULE_LICENSE("GPL"); 910 MODULE_DESCRIPTION("Quick & dirty crypto testing module"); 911 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>"); 912