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