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