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