xref: /openbmc/linux/crypto/tcrypt.c (revision ac5f3136)
1  // SPDX-License-Identifier: GPL-2.0-or-later
2  /*
3   * Quick & dirty crypto testing module.
4   *
5   * This will only exist until we have a better testing mechanism
6   * (e.g. a char device).
7   *
8   * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
9   * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
10   * Copyright (c) 2007 Nokia Siemens Networks
11   *
12   * Updated RFC4106 AES-GCM testing.
13   *    Authors: Aidan O'Mahony (aidan.o.mahony@intel.com)
14   *             Adrian Hoban <adrian.hoban@intel.com>
15   *             Gabriele Paoloni <gabriele.paoloni@intel.com>
16   *             Tadeusz Struk (tadeusz.struk@intel.com)
17   *             Copyright (c) 2010, Intel Corporation.
18   */
19  
20  #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21  
22  #include <crypto/aead.h>
23  #include <crypto/hash.h>
24  #include <crypto/skcipher.h>
25  #include <linux/err.h>
26  #include <linux/fips.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  
38  /*
39   * Need slab memory for testing (size in number of pages).
40   */
41  #define TVMEMSIZE	4
42  
43  /*
44  * Used by test_cipher_speed()
45  */
46  #define ENCRYPT 1
47  #define DECRYPT 0
48  
49  #define MAX_DIGEST_SIZE		64
50  
51  /*
52   * return a string with the driver name
53   */
54  #define get_driver_name(tfm_type, tfm) crypto_tfm_alg_driver_name(tfm_type ## _tfm(tfm))
55  
56  /*
57   * Used by test_cipher_speed()
58   */
59  static unsigned int sec;
60  
61  static char *alg = NULL;
62  static u32 type;
63  static u32 mask;
64  static int mode;
65  static u32 num_mb = 8;
66  static unsigned int klen;
67  static char *tvmem[TVMEMSIZE];
68  
69  static const char *check[] = {
70  	"des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256", "sm3",
71  	"blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
72  	"cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
73  	"khazad", "wp512", "wp384", "wp256", "xeta",  "fcrypt",
74  	"camellia", "seed", "rmd160",
75  	"lzo", "lzo-rle", "cts", "sha3-224", "sha3-256", "sha3-384",
76  	"sha3-512", "streebog256", "streebog512",
77  	NULL
78  };
79  
80  static const int block_sizes[] = { 16, 64, 128, 256, 1024, 1420, 4096, 0 };
81  static const int aead_sizes[] = { 16, 64, 256, 512, 1024, 1420, 4096, 8192, 0 };
82  
83  #define XBUFSIZE 8
84  #define MAX_IVLEN 32
85  
86  static int testmgr_alloc_buf(char *buf[XBUFSIZE])
87  {
88  	int i;
89  
90  	for (i = 0; i < XBUFSIZE; i++) {
91  		buf[i] = (void *)__get_free_page(GFP_KERNEL);
92  		if (!buf[i])
93  			goto err_free_buf;
94  	}
95  
96  	return 0;
97  
98  err_free_buf:
99  	while (i-- > 0)
100  		free_page((unsigned long)buf[i]);
101  
102  	return -ENOMEM;
103  }
104  
105  static void testmgr_free_buf(char *buf[XBUFSIZE])
106  {
107  	int i;
108  
109  	for (i = 0; i < XBUFSIZE; i++)
110  		free_page((unsigned long)buf[i]);
111  }
112  
113  static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE],
114  			 unsigned int buflen, const void *assoc,
115  			 unsigned int aad_size)
116  {
117  	int np = (buflen + PAGE_SIZE - 1)/PAGE_SIZE;
118  	int k, rem;
119  
120  	if (np > XBUFSIZE) {
121  		rem = PAGE_SIZE;
122  		np = XBUFSIZE;
123  	} else {
124  		rem = buflen % PAGE_SIZE;
125  	}
126  
127  	sg_init_table(sg, np + 1);
128  
129  	sg_set_buf(&sg[0], assoc, aad_size);
130  
131  	if (rem)
132  		np--;
133  	for (k = 0; k < np; k++)
134  		sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE);
135  
136  	if (rem)
137  		sg_set_buf(&sg[k + 1], xbuf[k], rem);
138  }
139  
140  static inline int do_one_aead_op(struct aead_request *req, int ret)
141  {
142  	struct crypto_wait *wait = req->base.data;
143  
144  	return crypto_wait_req(ret, wait);
145  }
146  
147  struct test_mb_aead_data {
148  	struct scatterlist sg[XBUFSIZE];
149  	struct scatterlist sgout[XBUFSIZE];
150  	struct aead_request *req;
151  	struct crypto_wait wait;
152  	char *xbuf[XBUFSIZE];
153  	char *xoutbuf[XBUFSIZE];
154  	char *axbuf[XBUFSIZE];
155  };
156  
157  static int do_mult_aead_op(struct test_mb_aead_data *data, int enc,
158  				u32 num_mb, int *rc)
159  {
160  	int i, err = 0;
161  
162  	/* Fire up a bunch of concurrent requests */
163  	for (i = 0; i < num_mb; i++) {
164  		if (enc == ENCRYPT)
165  			rc[i] = crypto_aead_encrypt(data[i].req);
166  		else
167  			rc[i] = crypto_aead_decrypt(data[i].req);
168  	}
169  
170  	/* Wait for all requests to finish */
171  	for (i = 0; i < num_mb; i++) {
172  		rc[i] = crypto_wait_req(rc[i], &data[i].wait);
173  
174  		if (rc[i]) {
175  			pr_info("concurrent request %d error %d\n", i, rc[i]);
176  			err = rc[i];
177  		}
178  	}
179  
180  	return err;
181  }
182  
183  static int test_mb_aead_jiffies(struct test_mb_aead_data *data, int enc,
184  				int blen, int secs, u32 num_mb)
185  {
186  	unsigned long start, end;
187  	int bcount;
188  	int ret = 0;
189  	int *rc;
190  
191  	rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
192  	if (!rc)
193  		return -ENOMEM;
194  
195  	for (start = jiffies, end = start + secs * HZ, bcount = 0;
196  	     time_before(jiffies, end); bcount++) {
197  		ret = do_mult_aead_op(data, enc, num_mb, rc);
198  		if (ret)
199  			goto out;
200  	}
201  
202  	pr_cont("%d operations in %d seconds (%llu bytes)\n",
203  		bcount * num_mb, secs, (u64)bcount * blen * num_mb);
204  
205  out:
206  	kfree(rc);
207  	return ret;
208  }
209  
210  static int test_mb_aead_cycles(struct test_mb_aead_data *data, int enc,
211  			       int blen, u32 num_mb)
212  {
213  	unsigned long cycles = 0;
214  	int ret = 0;
215  	int i;
216  	int *rc;
217  
218  	rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
219  	if (!rc)
220  		return -ENOMEM;
221  
222  	/* Warm-up run. */
223  	for (i = 0; i < 4; i++) {
224  		ret = do_mult_aead_op(data, enc, num_mb, rc);
225  		if (ret)
226  			goto out;
227  	}
228  
229  	/* The real thing. */
230  	for (i = 0; i < 8; i++) {
231  		cycles_t start, end;
232  
233  		start = get_cycles();
234  		ret = do_mult_aead_op(data, enc, num_mb, rc);
235  		end = get_cycles();
236  
237  		if (ret)
238  			goto out;
239  
240  		cycles += end - start;
241  	}
242  
243  	pr_cont("1 operation in %lu cycles (%d bytes)\n",
244  		(cycles + 4) / (8 * num_mb), blen);
245  
246  out:
247  	kfree(rc);
248  	return ret;
249  }
250  
251  static void test_mb_aead_speed(const char *algo, int enc, int secs,
252  			       struct aead_speed_template *template,
253  			       unsigned int tcount, u8 authsize,
254  			       unsigned int aad_size, u8 *keysize, u32 num_mb)
255  {
256  	struct test_mb_aead_data *data;
257  	struct crypto_aead *tfm;
258  	unsigned int i, j, iv_len;
259  	const int *b_size;
260  	const char *key;
261  	const char *e;
262  	void *assoc;
263  	char *iv;
264  	int ret;
265  
266  
267  	if (aad_size >= PAGE_SIZE) {
268  		pr_err("associate data length (%u) too big\n", aad_size);
269  		return;
270  	}
271  
272  	iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
273  	if (!iv)
274  		return;
275  
276  	if (enc == ENCRYPT)
277  		e = "encryption";
278  	else
279  		e = "decryption";
280  
281  	data = kcalloc(num_mb, sizeof(*data), GFP_KERNEL);
282  	if (!data)
283  		goto out_free_iv;
284  
285  	tfm = crypto_alloc_aead(algo, 0, 0);
286  	if (IS_ERR(tfm)) {
287  		pr_err("failed to load transform for %s: %ld\n",
288  			algo, PTR_ERR(tfm));
289  		goto out_free_data;
290  	}
291  
292  	ret = crypto_aead_setauthsize(tfm, authsize);
293  	if (ret) {
294  		pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo,
295  		       ret);
296  		goto out_free_tfm;
297  	}
298  
299  	for (i = 0; i < num_mb; ++i)
300  		if (testmgr_alloc_buf(data[i].xbuf)) {
301  			while (i--)
302  				testmgr_free_buf(data[i].xbuf);
303  			goto out_free_tfm;
304  		}
305  
306  	for (i = 0; i < num_mb; ++i)
307  		if (testmgr_alloc_buf(data[i].axbuf)) {
308  			while (i--)
309  				testmgr_free_buf(data[i].axbuf);
310  			goto out_free_xbuf;
311  		}
312  
313  	for (i = 0; i < num_mb; ++i)
314  		if (testmgr_alloc_buf(data[i].xoutbuf)) {
315  			while (i--)
316  				testmgr_free_buf(data[i].xoutbuf);
317  			goto out_free_axbuf;
318  		}
319  
320  	for (i = 0; i < num_mb; ++i) {
321  		data[i].req = aead_request_alloc(tfm, GFP_KERNEL);
322  		if (!data[i].req) {
323  			pr_err("alg: aead: Failed to allocate request for %s\n",
324  			       algo);
325  			while (i--)
326  				aead_request_free(data[i].req);
327  			goto out_free_xoutbuf;
328  		}
329  	}
330  
331  	for (i = 0; i < num_mb; ++i) {
332  		crypto_init_wait(&data[i].wait);
333  		aead_request_set_callback(data[i].req,
334  					  CRYPTO_TFM_REQ_MAY_BACKLOG,
335  					  crypto_req_done, &data[i].wait);
336  	}
337  
338  	pr_info("\ntesting speed of multibuffer %s (%s) %s\n", algo,
339  		get_driver_name(crypto_aead, tfm), e);
340  
341  	i = 0;
342  	do {
343  		b_size = aead_sizes;
344  		do {
345  			int bs = round_up(*b_size, crypto_aead_blocksize(tfm));
346  
347  			if (bs + authsize > XBUFSIZE * PAGE_SIZE) {
348  				pr_err("template (%u) too big for buffer (%lu)\n",
349  				       authsize + bs,
350  				       XBUFSIZE * PAGE_SIZE);
351  				goto out;
352  			}
353  
354  			pr_info("test %u (%d bit key, %d byte blocks): ", i,
355  				*keysize * 8, bs);
356  
357  			/* Set up tfm global state, i.e. the key */
358  
359  			memset(tvmem[0], 0xff, PAGE_SIZE);
360  			key = tvmem[0];
361  			for (j = 0; j < tcount; j++) {
362  				if (template[j].klen == *keysize) {
363  					key = template[j].key;
364  					break;
365  				}
366  			}
367  
368  			crypto_aead_clear_flags(tfm, ~0);
369  
370  			ret = crypto_aead_setkey(tfm, key, *keysize);
371  			if (ret) {
372  				pr_err("setkey() failed flags=%x\n",
373  				       crypto_aead_get_flags(tfm));
374  				goto out;
375  			}
376  
377  			iv_len = crypto_aead_ivsize(tfm);
378  			if (iv_len)
379  				memset(iv, 0xff, iv_len);
380  
381  			/* Now setup per request stuff, i.e. buffers */
382  
383  			for (j = 0; j < num_mb; ++j) {
384  				struct test_mb_aead_data *cur = &data[j];
385  
386  				assoc = cur->axbuf[0];
387  				memset(assoc, 0xff, aad_size);
388  
389  				sg_init_aead(cur->sg, cur->xbuf,
390  					     bs + (enc ? 0 : authsize),
391  					     assoc, aad_size);
392  
393  				sg_init_aead(cur->sgout, cur->xoutbuf,
394  					     bs + (enc ? authsize : 0),
395  					     assoc, aad_size);
396  
397  				aead_request_set_ad(cur->req, aad_size);
398  
399  				if (!enc) {
400  
401  					aead_request_set_crypt(cur->req,
402  							       cur->sgout,
403  							       cur->sg,
404  							       bs, iv);
405  					ret = crypto_aead_encrypt(cur->req);
406  					ret = do_one_aead_op(cur->req, ret);
407  
408  					if (ret) {
409  						pr_err("calculating auth failed (%d)\n",
410  						       ret);
411  						break;
412  					}
413  				}
414  
415  				aead_request_set_crypt(cur->req, cur->sg,
416  						       cur->sgout, bs +
417  						       (enc ? 0 : authsize),
418  						       iv);
419  
420  			}
421  
422  			if (secs) {
423  				ret = test_mb_aead_jiffies(data, enc, bs,
424  							   secs, num_mb);
425  				cond_resched();
426  			} else {
427  				ret = test_mb_aead_cycles(data, enc, bs,
428  							  num_mb);
429  			}
430  
431  			if (ret) {
432  				pr_err("%s() failed return code=%d\n", e, ret);
433  				break;
434  			}
435  			b_size++;
436  			i++;
437  		} while (*b_size);
438  		keysize++;
439  	} while (*keysize);
440  
441  out:
442  	for (i = 0; i < num_mb; ++i)
443  		aead_request_free(data[i].req);
444  out_free_xoutbuf:
445  	for (i = 0; i < num_mb; ++i)
446  		testmgr_free_buf(data[i].xoutbuf);
447  out_free_axbuf:
448  	for (i = 0; i < num_mb; ++i)
449  		testmgr_free_buf(data[i].axbuf);
450  out_free_xbuf:
451  	for (i = 0; i < num_mb; ++i)
452  		testmgr_free_buf(data[i].xbuf);
453  out_free_tfm:
454  	crypto_free_aead(tfm);
455  out_free_data:
456  	kfree(data);
457  out_free_iv:
458  	kfree(iv);
459  }
460  
461  static int test_aead_jiffies(struct aead_request *req, int enc,
462  				int blen, int secs)
463  {
464  	unsigned long start, end;
465  	int bcount;
466  	int ret;
467  
468  	for (start = jiffies, end = start + secs * HZ, bcount = 0;
469  	     time_before(jiffies, end); bcount++) {
470  		if (enc)
471  			ret = do_one_aead_op(req, crypto_aead_encrypt(req));
472  		else
473  			ret = do_one_aead_op(req, crypto_aead_decrypt(req));
474  
475  		if (ret)
476  			return ret;
477  	}
478  
479  	pr_cont("%d operations in %d seconds (%llu bytes)\n",
480  	        bcount, secs, (u64)bcount * blen);
481  	return 0;
482  }
483  
484  static int test_aead_cycles(struct aead_request *req, int enc, int blen)
485  {
486  	unsigned long cycles = 0;
487  	int ret = 0;
488  	int i;
489  
490  	/* Warm-up run. */
491  	for (i = 0; i < 4; i++) {
492  		if (enc)
493  			ret = do_one_aead_op(req, crypto_aead_encrypt(req));
494  		else
495  			ret = do_one_aead_op(req, crypto_aead_decrypt(req));
496  
497  		if (ret)
498  			goto out;
499  	}
500  
501  	/* The real thing. */
502  	for (i = 0; i < 8; i++) {
503  		cycles_t start, end;
504  
505  		start = get_cycles();
506  		if (enc)
507  			ret = do_one_aead_op(req, crypto_aead_encrypt(req));
508  		else
509  			ret = do_one_aead_op(req, crypto_aead_decrypt(req));
510  		end = get_cycles();
511  
512  		if (ret)
513  			goto out;
514  
515  		cycles += end - start;
516  	}
517  
518  out:
519  	if (ret == 0)
520  		printk("1 operation in %lu cycles (%d bytes)\n",
521  		       (cycles + 4) / 8, blen);
522  
523  	return ret;
524  }
525  
526  static void test_aead_speed(const char *algo, int enc, unsigned int secs,
527  			    struct aead_speed_template *template,
528  			    unsigned int tcount, u8 authsize,
529  			    unsigned int aad_size, u8 *keysize)
530  {
531  	unsigned int i, j;
532  	struct crypto_aead *tfm;
533  	int ret = -ENOMEM;
534  	const char *key;
535  	struct aead_request *req;
536  	struct scatterlist *sg;
537  	struct scatterlist *sgout;
538  	const char *e;
539  	void *assoc;
540  	char *iv;
541  	char *xbuf[XBUFSIZE];
542  	char *xoutbuf[XBUFSIZE];
543  	char *axbuf[XBUFSIZE];
544  	const int *b_size;
545  	unsigned int iv_len;
546  	struct crypto_wait wait;
547  
548  	iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
549  	if (!iv)
550  		return;
551  
552  	if (aad_size >= PAGE_SIZE) {
553  		pr_err("associate data length (%u) too big\n", aad_size);
554  		goto out_noxbuf;
555  	}
556  
557  	if (enc == ENCRYPT)
558  		e = "encryption";
559  	else
560  		e = "decryption";
561  
562  	if (testmgr_alloc_buf(xbuf))
563  		goto out_noxbuf;
564  	if (testmgr_alloc_buf(axbuf))
565  		goto out_noaxbuf;
566  	if (testmgr_alloc_buf(xoutbuf))
567  		goto out_nooutbuf;
568  
569  	sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL);
570  	if (!sg)
571  		goto out_nosg;
572  	sgout = &sg[9];
573  
574  	tfm = crypto_alloc_aead(algo, 0, 0);
575  	if (IS_ERR(tfm)) {
576  		pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo,
577  		       PTR_ERR(tfm));
578  		goto out_notfm;
579  	}
580  
581  	ret = crypto_aead_setauthsize(tfm, authsize);
582  	if (ret) {
583  		pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo,
584  		       ret);
585  		goto out_noreq;
586  	}
587  
588  	crypto_init_wait(&wait);
589  	printk(KERN_INFO "\ntesting speed of %s (%s) %s\n", algo,
590  			get_driver_name(crypto_aead, tfm), e);
591  
592  	req = aead_request_alloc(tfm, GFP_KERNEL);
593  	if (!req) {
594  		pr_err("alg: aead: Failed to allocate request for %s\n",
595  		       algo);
596  		goto out_noreq;
597  	}
598  
599  	aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
600  				  crypto_req_done, &wait);
601  
602  	i = 0;
603  	do {
604  		b_size = aead_sizes;
605  		do {
606  			u32 bs = round_up(*b_size, crypto_aead_blocksize(tfm));
607  
608  			assoc = axbuf[0];
609  			memset(assoc, 0xff, aad_size);
610  
611  			if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) {
612  				pr_err("template (%u) too big for tvmem (%lu)\n",
613  				       *keysize + bs,
614  					TVMEMSIZE * PAGE_SIZE);
615  				goto out;
616  			}
617  
618  			key = tvmem[0];
619  			for (j = 0; j < tcount; j++) {
620  				if (template[j].klen == *keysize) {
621  					key = template[j].key;
622  					break;
623  				}
624  			}
625  
626  			ret = crypto_aead_setkey(tfm, key, *keysize);
627  			if (ret) {
628  				pr_err("setkey() failed flags=%x: %d\n",
629  					crypto_aead_get_flags(tfm), ret);
630  				goto out;
631  			}
632  
633  			iv_len = crypto_aead_ivsize(tfm);
634  			if (iv_len)
635  				memset(iv, 0xff, iv_len);
636  
637  			crypto_aead_clear_flags(tfm, ~0);
638  			printk(KERN_INFO "test %u (%d bit key, %d byte blocks): ",
639  					i, *keysize * 8, bs);
640  
641  			memset(tvmem[0], 0xff, PAGE_SIZE);
642  
643  			sg_init_aead(sg, xbuf, bs + (enc ? 0 : authsize),
644  				     assoc, aad_size);
645  
646  			sg_init_aead(sgout, xoutbuf,
647  				     bs + (enc ? authsize : 0), assoc,
648  				     aad_size);
649  
650  			aead_request_set_ad(req, aad_size);
651  
652  			if (!enc) {
653  
654  				/*
655  				 * For decryption we need a proper auth so
656  				 * we do the encryption path once with buffers
657  				 * reversed (input <-> output) to calculate it
658  				 */
659  				aead_request_set_crypt(req, sgout, sg,
660  						       bs, iv);
661  				ret = do_one_aead_op(req,
662  						     crypto_aead_encrypt(req));
663  
664  				if (ret) {
665  					pr_err("calculating auth failed (%d)\n",
666  					       ret);
667  					break;
668  				}
669  			}
670  
671  			aead_request_set_crypt(req, sg, sgout,
672  					       bs + (enc ? 0 : authsize),
673  					       iv);
674  
675  			if (secs) {
676  				ret = test_aead_jiffies(req, enc, bs,
677  							secs);
678  				cond_resched();
679  			} else {
680  				ret = test_aead_cycles(req, enc, bs);
681  			}
682  
683  			if (ret) {
684  				pr_err("%s() failed return code=%d\n", e, ret);
685  				break;
686  			}
687  			b_size++;
688  			i++;
689  		} while (*b_size);
690  		keysize++;
691  	} while (*keysize);
692  
693  out:
694  	aead_request_free(req);
695  out_noreq:
696  	crypto_free_aead(tfm);
697  out_notfm:
698  	kfree(sg);
699  out_nosg:
700  	testmgr_free_buf(xoutbuf);
701  out_nooutbuf:
702  	testmgr_free_buf(axbuf);
703  out_noaxbuf:
704  	testmgr_free_buf(xbuf);
705  out_noxbuf:
706  	kfree(iv);
707  }
708  
709  static void test_hash_sg_init(struct scatterlist *sg)
710  {
711  	int i;
712  
713  	sg_init_table(sg, TVMEMSIZE);
714  	for (i = 0; i < TVMEMSIZE; i++) {
715  		sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
716  		memset(tvmem[i], 0xff, PAGE_SIZE);
717  	}
718  }
719  
720  static inline int do_one_ahash_op(struct ahash_request *req, int ret)
721  {
722  	struct crypto_wait *wait = req->base.data;
723  
724  	return crypto_wait_req(ret, wait);
725  }
726  
727  struct test_mb_ahash_data {
728  	struct scatterlist sg[XBUFSIZE];
729  	char result[64];
730  	struct ahash_request *req;
731  	struct crypto_wait wait;
732  	char *xbuf[XBUFSIZE];
733  };
734  
735  static inline int do_mult_ahash_op(struct test_mb_ahash_data *data, u32 num_mb,
736  				   int *rc)
737  {
738  	int i, err = 0;
739  
740  	/* Fire up a bunch of concurrent requests */
741  	for (i = 0; i < num_mb; i++)
742  		rc[i] = crypto_ahash_digest(data[i].req);
743  
744  	/* Wait for all requests to finish */
745  	for (i = 0; i < num_mb; i++) {
746  		rc[i] = crypto_wait_req(rc[i], &data[i].wait);
747  
748  		if (rc[i]) {
749  			pr_info("concurrent request %d error %d\n", i, rc[i]);
750  			err = rc[i];
751  		}
752  	}
753  
754  	return err;
755  }
756  
757  static int test_mb_ahash_jiffies(struct test_mb_ahash_data *data, int blen,
758  				 int secs, u32 num_mb)
759  {
760  	unsigned long start, end;
761  	int bcount;
762  	int ret = 0;
763  	int *rc;
764  
765  	rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
766  	if (!rc)
767  		return -ENOMEM;
768  
769  	for (start = jiffies, end = start + secs * HZ, bcount = 0;
770  	     time_before(jiffies, end); bcount++) {
771  		ret = do_mult_ahash_op(data, num_mb, rc);
772  		if (ret)
773  			goto out;
774  	}
775  
776  	pr_cont("%d operations in %d seconds (%llu bytes)\n",
777  		bcount * num_mb, secs, (u64)bcount * blen * num_mb);
778  
779  out:
780  	kfree(rc);
781  	return ret;
782  }
783  
784  static int test_mb_ahash_cycles(struct test_mb_ahash_data *data, int blen,
785  				u32 num_mb)
786  {
787  	unsigned long cycles = 0;
788  	int ret = 0;
789  	int i;
790  	int *rc;
791  
792  	rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
793  	if (!rc)
794  		return -ENOMEM;
795  
796  	/* Warm-up run. */
797  	for (i = 0; i < 4; i++) {
798  		ret = do_mult_ahash_op(data, num_mb, rc);
799  		if (ret)
800  			goto out;
801  	}
802  
803  	/* The real thing. */
804  	for (i = 0; i < 8; i++) {
805  		cycles_t start, end;
806  
807  		start = get_cycles();
808  		ret = do_mult_ahash_op(data, num_mb, rc);
809  		end = get_cycles();
810  
811  		if (ret)
812  			goto out;
813  
814  		cycles += end - start;
815  	}
816  
817  	pr_cont("1 operation in %lu cycles (%d bytes)\n",
818  		(cycles + 4) / (8 * num_mb), blen);
819  
820  out:
821  	kfree(rc);
822  	return ret;
823  }
824  
825  static void test_mb_ahash_speed(const char *algo, unsigned int secs,
826  				struct hash_speed *speed, u32 num_mb)
827  {
828  	struct test_mb_ahash_data *data;
829  	struct crypto_ahash *tfm;
830  	unsigned int i, j, k;
831  	int ret;
832  
833  	data = kcalloc(num_mb, sizeof(*data), GFP_KERNEL);
834  	if (!data)
835  		return;
836  
837  	tfm = crypto_alloc_ahash(algo, 0, 0);
838  	if (IS_ERR(tfm)) {
839  		pr_err("failed to load transform for %s: %ld\n",
840  			algo, PTR_ERR(tfm));
841  		goto free_data;
842  	}
843  
844  	for (i = 0; i < num_mb; ++i) {
845  		if (testmgr_alloc_buf(data[i].xbuf))
846  			goto out;
847  
848  		crypto_init_wait(&data[i].wait);
849  
850  		data[i].req = ahash_request_alloc(tfm, GFP_KERNEL);
851  		if (!data[i].req) {
852  			pr_err("alg: hash: Failed to allocate request for %s\n",
853  			       algo);
854  			goto out;
855  		}
856  
857  		ahash_request_set_callback(data[i].req, 0, crypto_req_done,
858  					   &data[i].wait);
859  
860  		sg_init_table(data[i].sg, XBUFSIZE);
861  		for (j = 0; j < XBUFSIZE; j++) {
862  			sg_set_buf(data[i].sg + j, data[i].xbuf[j], PAGE_SIZE);
863  			memset(data[i].xbuf[j], 0xff, PAGE_SIZE);
864  		}
865  	}
866  
867  	pr_info("\ntesting speed of multibuffer %s (%s)\n", algo,
868  		get_driver_name(crypto_ahash, tfm));
869  
870  	for (i = 0; speed[i].blen != 0; i++) {
871  		/* For some reason this only tests digests. */
872  		if (speed[i].blen != speed[i].plen)
873  			continue;
874  
875  		if (speed[i].blen > XBUFSIZE * PAGE_SIZE) {
876  			pr_err("template (%u) too big for tvmem (%lu)\n",
877  			       speed[i].blen, XBUFSIZE * PAGE_SIZE);
878  			goto out;
879  		}
880  
881  		if (klen)
882  			crypto_ahash_setkey(tfm, tvmem[0], klen);
883  
884  		for (k = 0; k < num_mb; k++)
885  			ahash_request_set_crypt(data[k].req, data[k].sg,
886  						data[k].result, speed[i].blen);
887  
888  		pr_info("test%3u "
889  			"(%5u byte blocks,%5u bytes per update,%4u updates): ",
890  			i, speed[i].blen, speed[i].plen,
891  			speed[i].blen / speed[i].plen);
892  
893  		if (secs) {
894  			ret = test_mb_ahash_jiffies(data, speed[i].blen, secs,
895  						    num_mb);
896  			cond_resched();
897  		} else {
898  			ret = test_mb_ahash_cycles(data, speed[i].blen, num_mb);
899  		}
900  
901  
902  		if (ret) {
903  			pr_err("At least one hashing failed ret=%d\n", ret);
904  			break;
905  		}
906  	}
907  
908  out:
909  	for (k = 0; k < num_mb; ++k)
910  		ahash_request_free(data[k].req);
911  
912  	for (k = 0; k < num_mb; ++k)
913  		testmgr_free_buf(data[k].xbuf);
914  
915  	crypto_free_ahash(tfm);
916  
917  free_data:
918  	kfree(data);
919  }
920  
921  static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
922  				     char *out, int secs)
923  {
924  	unsigned long start, end;
925  	int bcount;
926  	int ret;
927  
928  	for (start = jiffies, end = start + secs * HZ, bcount = 0;
929  	     time_before(jiffies, end); bcount++) {
930  		ret = do_one_ahash_op(req, crypto_ahash_digest(req));
931  		if (ret)
932  			return ret;
933  	}
934  
935  	printk("%6u opers/sec, %9lu bytes/sec\n",
936  	       bcount / secs, ((long)bcount * blen) / secs);
937  
938  	return 0;
939  }
940  
941  static int test_ahash_jiffies(struct ahash_request *req, int blen,
942  			      int plen, char *out, int secs)
943  {
944  	unsigned long start, end;
945  	int bcount, pcount;
946  	int ret;
947  
948  	if (plen == blen)
949  		return test_ahash_jiffies_digest(req, blen, out, secs);
950  
951  	for (start = jiffies, end = start + secs * HZ, bcount = 0;
952  	     time_before(jiffies, end); bcount++) {
953  		ret = do_one_ahash_op(req, crypto_ahash_init(req));
954  		if (ret)
955  			return ret;
956  		for (pcount = 0; pcount < blen; pcount += plen) {
957  			ret = do_one_ahash_op(req, crypto_ahash_update(req));
958  			if (ret)
959  				return ret;
960  		}
961  		/* we assume there is enough space in 'out' for the result */
962  		ret = do_one_ahash_op(req, crypto_ahash_final(req));
963  		if (ret)
964  			return ret;
965  	}
966  
967  	pr_cont("%6u opers/sec, %9lu bytes/sec\n",
968  		bcount / secs, ((long)bcount * blen) / secs);
969  
970  	return 0;
971  }
972  
973  static int test_ahash_cycles_digest(struct ahash_request *req, int blen,
974  				    char *out)
975  {
976  	unsigned long cycles = 0;
977  	int ret, i;
978  
979  	/* Warm-up run. */
980  	for (i = 0; i < 4; i++) {
981  		ret = do_one_ahash_op(req, crypto_ahash_digest(req));
982  		if (ret)
983  			goto out;
984  	}
985  
986  	/* The real thing. */
987  	for (i = 0; i < 8; i++) {
988  		cycles_t start, end;
989  
990  		start = get_cycles();
991  
992  		ret = do_one_ahash_op(req, crypto_ahash_digest(req));
993  		if (ret)
994  			goto out;
995  
996  		end = get_cycles();
997  
998  		cycles += end - start;
999  	}
1000  
1001  out:
1002  	if (ret)
1003  		return ret;
1004  
1005  	pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
1006  		cycles / 8, cycles / (8 * blen));
1007  
1008  	return 0;
1009  }
1010  
1011  static int test_ahash_cycles(struct ahash_request *req, int blen,
1012  			     int plen, char *out)
1013  {
1014  	unsigned long cycles = 0;
1015  	int i, pcount, ret;
1016  
1017  	if (plen == blen)
1018  		return test_ahash_cycles_digest(req, blen, out);
1019  
1020  	/* Warm-up run. */
1021  	for (i = 0; i < 4; i++) {
1022  		ret = do_one_ahash_op(req, crypto_ahash_init(req));
1023  		if (ret)
1024  			goto out;
1025  		for (pcount = 0; pcount < blen; pcount += plen) {
1026  			ret = do_one_ahash_op(req, crypto_ahash_update(req));
1027  			if (ret)
1028  				goto out;
1029  		}
1030  		ret = do_one_ahash_op(req, crypto_ahash_final(req));
1031  		if (ret)
1032  			goto out;
1033  	}
1034  
1035  	/* The real thing. */
1036  	for (i = 0; i < 8; i++) {
1037  		cycles_t start, end;
1038  
1039  		start = get_cycles();
1040  
1041  		ret = do_one_ahash_op(req, crypto_ahash_init(req));
1042  		if (ret)
1043  			goto out;
1044  		for (pcount = 0; pcount < blen; pcount += plen) {
1045  			ret = do_one_ahash_op(req, crypto_ahash_update(req));
1046  			if (ret)
1047  				goto out;
1048  		}
1049  		ret = do_one_ahash_op(req, crypto_ahash_final(req));
1050  		if (ret)
1051  			goto out;
1052  
1053  		end = get_cycles();
1054  
1055  		cycles += end - start;
1056  	}
1057  
1058  out:
1059  	if (ret)
1060  		return ret;
1061  
1062  	pr_cont("%6lu cycles/operation, %4lu cycles/byte\n",
1063  		cycles / 8, cycles / (8 * blen));
1064  
1065  	return 0;
1066  }
1067  
1068  static void test_ahash_speed_common(const char *algo, unsigned int secs,
1069  				    struct hash_speed *speed, unsigned mask)
1070  {
1071  	struct scatterlist sg[TVMEMSIZE];
1072  	struct crypto_wait wait;
1073  	struct ahash_request *req;
1074  	struct crypto_ahash *tfm;
1075  	char *output;
1076  	int i, ret;
1077  
1078  	tfm = crypto_alloc_ahash(algo, 0, mask);
1079  	if (IS_ERR(tfm)) {
1080  		pr_err("failed to load transform for %s: %ld\n",
1081  		       algo, PTR_ERR(tfm));
1082  		return;
1083  	}
1084  
1085  	printk(KERN_INFO "\ntesting speed of async %s (%s)\n", algo,
1086  			get_driver_name(crypto_ahash, tfm));
1087  
1088  	if (crypto_ahash_digestsize(tfm) > MAX_DIGEST_SIZE) {
1089  		pr_err("digestsize(%u) > %d\n", crypto_ahash_digestsize(tfm),
1090  		       MAX_DIGEST_SIZE);
1091  		goto out;
1092  	}
1093  
1094  	test_hash_sg_init(sg);
1095  	req = ahash_request_alloc(tfm, GFP_KERNEL);
1096  	if (!req) {
1097  		pr_err("ahash request allocation failure\n");
1098  		goto out;
1099  	}
1100  
1101  	crypto_init_wait(&wait);
1102  	ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1103  				   crypto_req_done, &wait);
1104  
1105  	output = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
1106  	if (!output)
1107  		goto out_nomem;
1108  
1109  	for (i = 0; speed[i].blen != 0; i++) {
1110  		if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
1111  			pr_err("template (%u) too big for tvmem (%lu)\n",
1112  			       speed[i].blen, TVMEMSIZE * PAGE_SIZE);
1113  			break;
1114  		}
1115  
1116  		if (klen)
1117  			crypto_ahash_setkey(tfm, tvmem[0], klen);
1118  
1119  		pr_info("test%3u "
1120  			"(%5u byte blocks,%5u bytes per update,%4u updates): ",
1121  			i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
1122  
1123  		ahash_request_set_crypt(req, sg, output, speed[i].plen);
1124  
1125  		if (secs) {
1126  			ret = test_ahash_jiffies(req, speed[i].blen,
1127  						 speed[i].plen, output, secs);
1128  			cond_resched();
1129  		} else {
1130  			ret = test_ahash_cycles(req, speed[i].blen,
1131  						speed[i].plen, output);
1132  		}
1133  
1134  		if (ret) {
1135  			pr_err("hashing failed ret=%d\n", ret);
1136  			break;
1137  		}
1138  	}
1139  
1140  	kfree(output);
1141  
1142  out_nomem:
1143  	ahash_request_free(req);
1144  
1145  out:
1146  	crypto_free_ahash(tfm);
1147  }
1148  
1149  static void test_ahash_speed(const char *algo, unsigned int secs,
1150  			     struct hash_speed *speed)
1151  {
1152  	return test_ahash_speed_common(algo, secs, speed, 0);
1153  }
1154  
1155  static void test_hash_speed(const char *algo, unsigned int secs,
1156  			    struct hash_speed *speed)
1157  {
1158  	return test_ahash_speed_common(algo, secs, speed, CRYPTO_ALG_ASYNC);
1159  }
1160  
1161  struct test_mb_skcipher_data {
1162  	struct scatterlist sg[XBUFSIZE];
1163  	struct skcipher_request *req;
1164  	struct crypto_wait wait;
1165  	char *xbuf[XBUFSIZE];
1166  };
1167  
1168  static int do_mult_acipher_op(struct test_mb_skcipher_data *data, int enc,
1169  				u32 num_mb, int *rc)
1170  {
1171  	int i, err = 0;
1172  
1173  	/* Fire up a bunch of concurrent requests */
1174  	for (i = 0; i < num_mb; i++) {
1175  		if (enc == ENCRYPT)
1176  			rc[i] = crypto_skcipher_encrypt(data[i].req);
1177  		else
1178  			rc[i] = crypto_skcipher_decrypt(data[i].req);
1179  	}
1180  
1181  	/* Wait for all requests to finish */
1182  	for (i = 0; i < num_mb; i++) {
1183  		rc[i] = crypto_wait_req(rc[i], &data[i].wait);
1184  
1185  		if (rc[i]) {
1186  			pr_info("concurrent request %d error %d\n", i, rc[i]);
1187  			err = rc[i];
1188  		}
1189  	}
1190  
1191  	return err;
1192  }
1193  
1194  static int test_mb_acipher_jiffies(struct test_mb_skcipher_data *data, int enc,
1195  				int blen, int secs, u32 num_mb)
1196  {
1197  	unsigned long start, end;
1198  	int bcount;
1199  	int ret = 0;
1200  	int *rc;
1201  
1202  	rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
1203  	if (!rc)
1204  		return -ENOMEM;
1205  
1206  	for (start = jiffies, end = start + secs * HZ, bcount = 0;
1207  	     time_before(jiffies, end); bcount++) {
1208  		ret = do_mult_acipher_op(data, enc, num_mb, rc);
1209  		if (ret)
1210  			goto out;
1211  	}
1212  
1213  	pr_cont("%d operations in %d seconds (%llu bytes)\n",
1214  		bcount * num_mb, secs, (u64)bcount * blen * num_mb);
1215  
1216  out:
1217  	kfree(rc);
1218  	return ret;
1219  }
1220  
1221  static int test_mb_acipher_cycles(struct test_mb_skcipher_data *data, int enc,
1222  			       int blen, u32 num_mb)
1223  {
1224  	unsigned long cycles = 0;
1225  	int ret = 0;
1226  	int i;
1227  	int *rc;
1228  
1229  	rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
1230  	if (!rc)
1231  		return -ENOMEM;
1232  
1233  	/* Warm-up run. */
1234  	for (i = 0; i < 4; i++) {
1235  		ret = do_mult_acipher_op(data, enc, num_mb, rc);
1236  		if (ret)
1237  			goto out;
1238  	}
1239  
1240  	/* The real thing. */
1241  	for (i = 0; i < 8; i++) {
1242  		cycles_t start, end;
1243  
1244  		start = get_cycles();
1245  		ret = do_mult_acipher_op(data, enc, num_mb, rc);
1246  		end = get_cycles();
1247  
1248  		if (ret)
1249  			goto out;
1250  
1251  		cycles += end - start;
1252  	}
1253  
1254  	pr_cont("1 operation in %lu cycles (%d bytes)\n",
1255  		(cycles + 4) / (8 * num_mb), blen);
1256  
1257  out:
1258  	kfree(rc);
1259  	return ret;
1260  }
1261  
1262  static void test_mb_skcipher_speed(const char *algo, int enc, int secs,
1263  				   struct cipher_speed_template *template,
1264  				   unsigned int tcount, u8 *keysize, u32 num_mb)
1265  {
1266  	struct test_mb_skcipher_data *data;
1267  	struct crypto_skcipher *tfm;
1268  	unsigned int i, j, iv_len;
1269  	const int *b_size;
1270  	const char *key;
1271  	const char *e;
1272  	char iv[128];
1273  	int ret;
1274  
1275  	if (enc == ENCRYPT)
1276  		e = "encryption";
1277  	else
1278  		e = "decryption";
1279  
1280  	data = kcalloc(num_mb, sizeof(*data), GFP_KERNEL);
1281  	if (!data)
1282  		return;
1283  
1284  	tfm = crypto_alloc_skcipher(algo, 0, 0);
1285  	if (IS_ERR(tfm)) {
1286  		pr_err("failed to load transform for %s: %ld\n",
1287  			algo, PTR_ERR(tfm));
1288  		goto out_free_data;
1289  	}
1290  
1291  	for (i = 0; i < num_mb; ++i)
1292  		if (testmgr_alloc_buf(data[i].xbuf)) {
1293  			while (i--)
1294  				testmgr_free_buf(data[i].xbuf);
1295  			goto out_free_tfm;
1296  		}
1297  
1298  
1299  	for (i = 0; i < num_mb; ++i)
1300  		if (testmgr_alloc_buf(data[i].xbuf)) {
1301  			while (i--)
1302  				testmgr_free_buf(data[i].xbuf);
1303  			goto out_free_tfm;
1304  		}
1305  
1306  
1307  	for (i = 0; i < num_mb; ++i) {
1308  		data[i].req = skcipher_request_alloc(tfm, GFP_KERNEL);
1309  		if (!data[i].req) {
1310  			pr_err("alg: skcipher: Failed to allocate request for %s\n",
1311  			       algo);
1312  			while (i--)
1313  				skcipher_request_free(data[i].req);
1314  			goto out_free_xbuf;
1315  		}
1316  	}
1317  
1318  	for (i = 0; i < num_mb; ++i) {
1319  		skcipher_request_set_callback(data[i].req,
1320  					      CRYPTO_TFM_REQ_MAY_BACKLOG,
1321  					      crypto_req_done, &data[i].wait);
1322  		crypto_init_wait(&data[i].wait);
1323  	}
1324  
1325  	pr_info("\ntesting speed of multibuffer %s (%s) %s\n", algo,
1326  		get_driver_name(crypto_skcipher, tfm), e);
1327  
1328  	i = 0;
1329  	do {
1330  		b_size = block_sizes;
1331  		do {
1332  			u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm));
1333  
1334  			if (bs > XBUFSIZE * PAGE_SIZE) {
1335  				pr_err("template (%u) too big for buffer (%lu)\n",
1336  				       *b_size, XBUFSIZE * PAGE_SIZE);
1337  				goto out;
1338  			}
1339  
1340  			pr_info("test %u (%d bit key, %d byte blocks): ", i,
1341  				*keysize * 8, bs);
1342  
1343  			/* Set up tfm global state, i.e. the key */
1344  
1345  			memset(tvmem[0], 0xff, PAGE_SIZE);
1346  			key = tvmem[0];
1347  			for (j = 0; j < tcount; j++) {
1348  				if (template[j].klen == *keysize) {
1349  					key = template[j].key;
1350  					break;
1351  				}
1352  			}
1353  
1354  			crypto_skcipher_clear_flags(tfm, ~0);
1355  
1356  			ret = crypto_skcipher_setkey(tfm, key, *keysize);
1357  			if (ret) {
1358  				pr_err("setkey() failed flags=%x\n",
1359  				       crypto_skcipher_get_flags(tfm));
1360  				goto out;
1361  			}
1362  
1363  			iv_len = crypto_skcipher_ivsize(tfm);
1364  			if (iv_len)
1365  				memset(&iv, 0xff, iv_len);
1366  
1367  			/* Now setup per request stuff, i.e. buffers */
1368  
1369  			for (j = 0; j < num_mb; ++j) {
1370  				struct test_mb_skcipher_data *cur = &data[j];
1371  				unsigned int k = bs;
1372  				unsigned int pages = DIV_ROUND_UP(k, PAGE_SIZE);
1373  				unsigned int p = 0;
1374  
1375  				sg_init_table(cur->sg, pages);
1376  
1377  				while (k > PAGE_SIZE) {
1378  					sg_set_buf(cur->sg + p, cur->xbuf[p],
1379  						   PAGE_SIZE);
1380  					memset(cur->xbuf[p], 0xff, PAGE_SIZE);
1381  					p++;
1382  					k -= PAGE_SIZE;
1383  				}
1384  
1385  				sg_set_buf(cur->sg + p, cur->xbuf[p], k);
1386  				memset(cur->xbuf[p], 0xff, k);
1387  
1388  				skcipher_request_set_crypt(cur->req, cur->sg,
1389  							   cur->sg, *b_size,
1390  							   iv);
1391  			}
1392  
1393  			if (secs) {
1394  				ret = test_mb_acipher_jiffies(data, enc,
1395  							      bs, secs,
1396  							      num_mb);
1397  				cond_resched();
1398  			} else {
1399  				ret = test_mb_acipher_cycles(data, enc,
1400  							     bs, num_mb);
1401  			}
1402  
1403  			if (ret) {
1404  				pr_err("%s() failed flags=%x\n", e,
1405  				       crypto_skcipher_get_flags(tfm));
1406  				break;
1407  			}
1408  			b_size++;
1409  			i++;
1410  		} while (*b_size);
1411  		keysize++;
1412  	} while (*keysize);
1413  
1414  out:
1415  	for (i = 0; i < num_mb; ++i)
1416  		skcipher_request_free(data[i].req);
1417  out_free_xbuf:
1418  	for (i = 0; i < num_mb; ++i)
1419  		testmgr_free_buf(data[i].xbuf);
1420  out_free_tfm:
1421  	crypto_free_skcipher(tfm);
1422  out_free_data:
1423  	kfree(data);
1424  }
1425  
1426  static inline int do_one_acipher_op(struct skcipher_request *req, int ret)
1427  {
1428  	struct crypto_wait *wait = req->base.data;
1429  
1430  	return crypto_wait_req(ret, wait);
1431  }
1432  
1433  static int test_acipher_jiffies(struct skcipher_request *req, int enc,
1434  				int blen, int secs)
1435  {
1436  	unsigned long start, end;
1437  	int bcount;
1438  	int ret;
1439  
1440  	for (start = jiffies, end = start + secs * HZ, bcount = 0;
1441  	     time_before(jiffies, end); bcount++) {
1442  		if (enc)
1443  			ret = do_one_acipher_op(req,
1444  						crypto_skcipher_encrypt(req));
1445  		else
1446  			ret = do_one_acipher_op(req,
1447  						crypto_skcipher_decrypt(req));
1448  
1449  		if (ret)
1450  			return ret;
1451  	}
1452  
1453  	pr_cont("%d operations in %d seconds (%llu bytes)\n",
1454  		bcount, secs, (u64)bcount * blen);
1455  	return 0;
1456  }
1457  
1458  static int test_acipher_cycles(struct skcipher_request *req, int enc,
1459  			       int blen)
1460  {
1461  	unsigned long cycles = 0;
1462  	int ret = 0;
1463  	int i;
1464  
1465  	/* Warm-up run. */
1466  	for (i = 0; i < 4; i++) {
1467  		if (enc)
1468  			ret = do_one_acipher_op(req,
1469  						crypto_skcipher_encrypt(req));
1470  		else
1471  			ret = do_one_acipher_op(req,
1472  						crypto_skcipher_decrypt(req));
1473  
1474  		if (ret)
1475  			goto out;
1476  	}
1477  
1478  	/* The real thing. */
1479  	for (i = 0; i < 8; i++) {
1480  		cycles_t start, end;
1481  
1482  		start = get_cycles();
1483  		if (enc)
1484  			ret = do_one_acipher_op(req,
1485  						crypto_skcipher_encrypt(req));
1486  		else
1487  			ret = do_one_acipher_op(req,
1488  						crypto_skcipher_decrypt(req));
1489  		end = get_cycles();
1490  
1491  		if (ret)
1492  			goto out;
1493  
1494  		cycles += end - start;
1495  	}
1496  
1497  out:
1498  	if (ret == 0)
1499  		pr_cont("1 operation in %lu cycles (%d bytes)\n",
1500  			(cycles + 4) / 8, blen);
1501  
1502  	return ret;
1503  }
1504  
1505  static void test_skcipher_speed(const char *algo, int enc, unsigned int secs,
1506  				struct cipher_speed_template *template,
1507  				unsigned int tcount, u8 *keysize, bool async)
1508  {
1509  	unsigned int ret, i, j, k, iv_len;
1510  	struct crypto_wait wait;
1511  	const char *key;
1512  	char iv[128];
1513  	struct skcipher_request *req;
1514  	struct crypto_skcipher *tfm;
1515  	const int *b_size;
1516  	const char *e;
1517  
1518  	if (enc == ENCRYPT)
1519  		e = "encryption";
1520  	else
1521  		e = "decryption";
1522  
1523  	crypto_init_wait(&wait);
1524  
1525  	tfm = crypto_alloc_skcipher(algo, 0, async ? 0 : CRYPTO_ALG_ASYNC);
1526  
1527  	if (IS_ERR(tfm)) {
1528  		pr_err("failed to load transform for %s: %ld\n", algo,
1529  		       PTR_ERR(tfm));
1530  		return;
1531  	}
1532  
1533  	pr_info("\ntesting speed of %s %s (%s) %s\n", async ? "async" : "sync",
1534  		algo, get_driver_name(crypto_skcipher, tfm), e);
1535  
1536  	req = skcipher_request_alloc(tfm, GFP_KERNEL);
1537  	if (!req) {
1538  		pr_err("tcrypt: skcipher: Failed to allocate request for %s\n",
1539  		       algo);
1540  		goto out;
1541  	}
1542  
1543  	skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
1544  				      crypto_req_done, &wait);
1545  
1546  	i = 0;
1547  	do {
1548  		b_size = block_sizes;
1549  
1550  		do {
1551  			u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm));
1552  			struct scatterlist sg[TVMEMSIZE];
1553  
1554  			if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) {
1555  				pr_err("template (%u) too big for "
1556  				       "tvmem (%lu)\n", *keysize + bs,
1557  				       TVMEMSIZE * PAGE_SIZE);
1558  				goto out_free_req;
1559  			}
1560  
1561  			pr_info("test %u (%d bit key, %d byte blocks): ", i,
1562  				*keysize * 8, bs);
1563  
1564  			memset(tvmem[0], 0xff, PAGE_SIZE);
1565  
1566  			/* set key, plain text and IV */
1567  			key = tvmem[0];
1568  			for (j = 0; j < tcount; j++) {
1569  				if (template[j].klen == *keysize) {
1570  					key = template[j].key;
1571  					break;
1572  				}
1573  			}
1574  
1575  			crypto_skcipher_clear_flags(tfm, ~0);
1576  
1577  			ret = crypto_skcipher_setkey(tfm, key, *keysize);
1578  			if (ret) {
1579  				pr_err("setkey() failed flags=%x\n",
1580  					crypto_skcipher_get_flags(tfm));
1581  				goto out_free_req;
1582  			}
1583  
1584  			k = *keysize + bs;
1585  			sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE));
1586  
1587  			if (k > PAGE_SIZE) {
1588  				sg_set_buf(sg, tvmem[0] + *keysize,
1589  				   PAGE_SIZE - *keysize);
1590  				k -= PAGE_SIZE;
1591  				j = 1;
1592  				while (k > PAGE_SIZE) {
1593  					sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
1594  					memset(tvmem[j], 0xff, PAGE_SIZE);
1595  					j++;
1596  					k -= PAGE_SIZE;
1597  				}
1598  				sg_set_buf(sg + j, tvmem[j], k);
1599  				memset(tvmem[j], 0xff, k);
1600  			} else {
1601  				sg_set_buf(sg, tvmem[0] + *keysize, bs);
1602  			}
1603  
1604  			iv_len = crypto_skcipher_ivsize(tfm);
1605  			if (iv_len)
1606  				memset(&iv, 0xff, iv_len);
1607  
1608  			skcipher_request_set_crypt(req, sg, sg, bs, iv);
1609  
1610  			if (secs) {
1611  				ret = test_acipher_jiffies(req, enc,
1612  							   bs, secs);
1613  				cond_resched();
1614  			} else {
1615  				ret = test_acipher_cycles(req, enc,
1616  							  bs);
1617  			}
1618  
1619  			if (ret) {
1620  				pr_err("%s() failed flags=%x\n", e,
1621  				       crypto_skcipher_get_flags(tfm));
1622  				break;
1623  			}
1624  			b_size++;
1625  			i++;
1626  		} while (*b_size);
1627  		keysize++;
1628  	} while (*keysize);
1629  
1630  out_free_req:
1631  	skcipher_request_free(req);
1632  out:
1633  	crypto_free_skcipher(tfm);
1634  }
1635  
1636  static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
1637  			       struct cipher_speed_template *template,
1638  			       unsigned int tcount, u8 *keysize)
1639  {
1640  	return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
1641  				   true);
1642  }
1643  
1644  static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
1645  			      struct cipher_speed_template *template,
1646  			      unsigned int tcount, u8 *keysize)
1647  {
1648  	return test_skcipher_speed(algo, enc, secs, template, tcount, keysize,
1649  				   false);
1650  }
1651  
1652  static void test_available(void)
1653  {
1654  	const char **name = check;
1655  
1656  	while (*name) {
1657  		printk("alg %s ", *name);
1658  		printk(crypto_has_alg(*name, 0, 0) ?
1659  		       "found\n" : "not found\n");
1660  		name++;
1661  	}
1662  }
1663  
1664  static inline int tcrypt_test(const char *alg)
1665  {
1666  	int ret;
1667  
1668  	pr_debug("testing %s\n", alg);
1669  
1670  	ret = alg_test(alg, alg, 0, 0);
1671  	/* non-fips algs return -EINVAL in fips mode */
1672  	if (fips_enabled && ret == -EINVAL)
1673  		ret = 0;
1674  	return ret;
1675  }
1676  
1677  static int do_test(const char *alg, u32 type, u32 mask, int m, u32 num_mb)
1678  {
1679  	int i;
1680  	int ret = 0;
1681  
1682  	switch (m) {
1683  	case 0:
1684  		if (alg) {
1685  			if (!crypto_has_alg(alg, type,
1686  					    mask ?: CRYPTO_ALG_TYPE_MASK))
1687  				ret = -ENOENT;
1688  			break;
1689  		}
1690  
1691  		for (i = 1; i < 200; i++)
1692  			ret += do_test(NULL, 0, 0, i, num_mb);
1693  		break;
1694  
1695  	case 1:
1696  		ret += tcrypt_test("md5");
1697  		break;
1698  
1699  	case 2:
1700  		ret += tcrypt_test("sha1");
1701  		break;
1702  
1703  	case 3:
1704  		ret += tcrypt_test("ecb(des)");
1705  		ret += tcrypt_test("cbc(des)");
1706  		ret += tcrypt_test("ctr(des)");
1707  		break;
1708  
1709  	case 4:
1710  		ret += tcrypt_test("ecb(des3_ede)");
1711  		ret += tcrypt_test("cbc(des3_ede)");
1712  		ret += tcrypt_test("ctr(des3_ede)");
1713  		break;
1714  
1715  	case 5:
1716  		ret += tcrypt_test("md4");
1717  		break;
1718  
1719  	case 6:
1720  		ret += tcrypt_test("sha256");
1721  		break;
1722  
1723  	case 7:
1724  		ret += tcrypt_test("ecb(blowfish)");
1725  		ret += tcrypt_test("cbc(blowfish)");
1726  		ret += tcrypt_test("ctr(blowfish)");
1727  		break;
1728  
1729  	case 8:
1730  		ret += tcrypt_test("ecb(twofish)");
1731  		ret += tcrypt_test("cbc(twofish)");
1732  		ret += tcrypt_test("ctr(twofish)");
1733  		ret += tcrypt_test("lrw(twofish)");
1734  		ret += tcrypt_test("xts(twofish)");
1735  		break;
1736  
1737  	case 9:
1738  		ret += tcrypt_test("ecb(serpent)");
1739  		ret += tcrypt_test("cbc(serpent)");
1740  		ret += tcrypt_test("ctr(serpent)");
1741  		ret += tcrypt_test("lrw(serpent)");
1742  		ret += tcrypt_test("xts(serpent)");
1743  		break;
1744  
1745  	case 10:
1746  		ret += tcrypt_test("ecb(aes)");
1747  		ret += tcrypt_test("cbc(aes)");
1748  		ret += tcrypt_test("lrw(aes)");
1749  		ret += tcrypt_test("xts(aes)");
1750  		ret += tcrypt_test("ctr(aes)");
1751  		ret += tcrypt_test("rfc3686(ctr(aes))");
1752  		ret += tcrypt_test("ofb(aes)");
1753  		ret += tcrypt_test("cfb(aes)");
1754  		break;
1755  
1756  	case 11:
1757  		ret += tcrypt_test("sha384");
1758  		break;
1759  
1760  	case 12:
1761  		ret += tcrypt_test("sha512");
1762  		break;
1763  
1764  	case 13:
1765  		ret += tcrypt_test("deflate");
1766  		break;
1767  
1768  	case 14:
1769  		ret += tcrypt_test("ecb(cast5)");
1770  		ret += tcrypt_test("cbc(cast5)");
1771  		ret += tcrypt_test("ctr(cast5)");
1772  		break;
1773  
1774  	case 15:
1775  		ret += tcrypt_test("ecb(cast6)");
1776  		ret += tcrypt_test("cbc(cast6)");
1777  		ret += tcrypt_test("ctr(cast6)");
1778  		ret += tcrypt_test("lrw(cast6)");
1779  		ret += tcrypt_test("xts(cast6)");
1780  		break;
1781  
1782  	case 16:
1783  		ret += tcrypt_test("ecb(arc4)");
1784  		break;
1785  
1786  	case 17:
1787  		ret += tcrypt_test("michael_mic");
1788  		break;
1789  
1790  	case 18:
1791  		ret += tcrypt_test("crc32c");
1792  		break;
1793  
1794  	case 19:
1795  		ret += tcrypt_test("ecb(tea)");
1796  		break;
1797  
1798  	case 20:
1799  		ret += tcrypt_test("ecb(xtea)");
1800  		break;
1801  
1802  	case 21:
1803  		ret += tcrypt_test("ecb(khazad)");
1804  		break;
1805  
1806  	case 22:
1807  		ret += tcrypt_test("wp512");
1808  		break;
1809  
1810  	case 23:
1811  		ret += tcrypt_test("wp384");
1812  		break;
1813  
1814  	case 24:
1815  		ret += tcrypt_test("wp256");
1816  		break;
1817  
1818  	case 26:
1819  		ret += tcrypt_test("ecb(anubis)");
1820  		ret += tcrypt_test("cbc(anubis)");
1821  		break;
1822  
1823  	case 30:
1824  		ret += tcrypt_test("ecb(xeta)");
1825  		break;
1826  
1827  	case 31:
1828  		ret += tcrypt_test("pcbc(fcrypt)");
1829  		break;
1830  
1831  	case 32:
1832  		ret += tcrypt_test("ecb(camellia)");
1833  		ret += tcrypt_test("cbc(camellia)");
1834  		ret += tcrypt_test("ctr(camellia)");
1835  		ret += tcrypt_test("lrw(camellia)");
1836  		ret += tcrypt_test("xts(camellia)");
1837  		break;
1838  
1839  	case 33:
1840  		ret += tcrypt_test("sha224");
1841  		break;
1842  
1843  	case 35:
1844  		ret += tcrypt_test("gcm(aes)");
1845  		break;
1846  
1847  	case 36:
1848  		ret += tcrypt_test("lzo");
1849  		break;
1850  
1851  	case 37:
1852  		ret += tcrypt_test("ccm(aes)");
1853  		break;
1854  
1855  	case 38:
1856  		ret += tcrypt_test("cts(cbc(aes))");
1857  		break;
1858  
1859          case 39:
1860  		ret += tcrypt_test("xxhash64");
1861  		break;
1862  
1863          case 40:
1864  		ret += tcrypt_test("rmd160");
1865  		break;
1866  
1867  	case 41:
1868  		ret += tcrypt_test("blake2s-256");
1869  		break;
1870  
1871  	case 42:
1872  		ret += tcrypt_test("blake2b-512");
1873  		break;
1874  
1875  	case 43:
1876  		ret += tcrypt_test("ecb(seed)");
1877  		break;
1878  
1879  	case 45:
1880  		ret += tcrypt_test("rfc4309(ccm(aes))");
1881  		break;
1882  
1883  	case 46:
1884  		ret += tcrypt_test("ghash");
1885  		break;
1886  
1887  	case 47:
1888  		ret += tcrypt_test("crct10dif");
1889  		break;
1890  
1891  	case 48:
1892  		ret += tcrypt_test("sha3-224");
1893  		break;
1894  
1895  	case 49:
1896  		ret += tcrypt_test("sha3-256");
1897  		break;
1898  
1899  	case 50:
1900  		ret += tcrypt_test("sha3-384");
1901  		break;
1902  
1903  	case 51:
1904  		ret += tcrypt_test("sha3-512");
1905  		break;
1906  
1907  	case 52:
1908  		ret += tcrypt_test("sm3");
1909  		break;
1910  
1911  	case 53:
1912  		ret += tcrypt_test("streebog256");
1913  		break;
1914  
1915  	case 54:
1916  		ret += tcrypt_test("streebog512");
1917  		break;
1918  
1919  	case 55:
1920  		ret += tcrypt_test("gcm(sm4)");
1921  		break;
1922  
1923  	case 56:
1924  		ret += tcrypt_test("ccm(sm4)");
1925  		break;
1926  
1927  	case 100:
1928  		ret += tcrypt_test("hmac(md5)");
1929  		break;
1930  
1931  	case 101:
1932  		ret += tcrypt_test("hmac(sha1)");
1933  		break;
1934  
1935  	case 102:
1936  		ret += tcrypt_test("hmac(sha256)");
1937  		break;
1938  
1939  	case 103:
1940  		ret += tcrypt_test("hmac(sha384)");
1941  		break;
1942  
1943  	case 104:
1944  		ret += tcrypt_test("hmac(sha512)");
1945  		break;
1946  
1947  	case 105:
1948  		ret += tcrypt_test("hmac(sha224)");
1949  		break;
1950  
1951  	case 106:
1952  		ret += tcrypt_test("xcbc(aes)");
1953  		break;
1954  
1955  	case 108:
1956  		ret += tcrypt_test("hmac(rmd160)");
1957  		break;
1958  
1959  	case 109:
1960  		ret += tcrypt_test("vmac64(aes)");
1961  		break;
1962  
1963  	case 111:
1964  		ret += tcrypt_test("hmac(sha3-224)");
1965  		break;
1966  
1967  	case 112:
1968  		ret += tcrypt_test("hmac(sha3-256)");
1969  		break;
1970  
1971  	case 113:
1972  		ret += tcrypt_test("hmac(sha3-384)");
1973  		break;
1974  
1975  	case 114:
1976  		ret += tcrypt_test("hmac(sha3-512)");
1977  		break;
1978  
1979  	case 115:
1980  		ret += tcrypt_test("hmac(streebog256)");
1981  		break;
1982  
1983  	case 116:
1984  		ret += tcrypt_test("hmac(streebog512)");
1985  		break;
1986  
1987  	case 150:
1988  		ret += tcrypt_test("ansi_cprng");
1989  		break;
1990  
1991  	case 151:
1992  		ret += tcrypt_test("rfc4106(gcm(aes))");
1993  		break;
1994  
1995  	case 152:
1996  		ret += tcrypt_test("rfc4543(gcm(aes))");
1997  		break;
1998  
1999  	case 153:
2000  		ret += tcrypt_test("cmac(aes)");
2001  		break;
2002  
2003  	case 154:
2004  		ret += tcrypt_test("cmac(des3_ede)");
2005  		break;
2006  
2007  	case 155:
2008  		ret += tcrypt_test("authenc(hmac(sha1),cbc(aes))");
2009  		break;
2010  
2011  	case 156:
2012  		ret += tcrypt_test("authenc(hmac(md5),ecb(cipher_null))");
2013  		break;
2014  
2015  	case 157:
2016  		ret += tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))");
2017  		break;
2018  
2019  	case 158:
2020  		ret += tcrypt_test("cbcmac(sm4)");
2021  		break;
2022  
2023  	case 159:
2024  		ret += tcrypt_test("cmac(sm4)");
2025  		break;
2026  
2027  	case 181:
2028  		ret += tcrypt_test("authenc(hmac(sha1),cbc(des))");
2029  		break;
2030  	case 182:
2031  		ret += tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))");
2032  		break;
2033  	case 183:
2034  		ret += tcrypt_test("authenc(hmac(sha224),cbc(des))");
2035  		break;
2036  	case 184:
2037  		ret += tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))");
2038  		break;
2039  	case 185:
2040  		ret += tcrypt_test("authenc(hmac(sha256),cbc(des))");
2041  		break;
2042  	case 186:
2043  		ret += tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))");
2044  		break;
2045  	case 187:
2046  		ret += tcrypt_test("authenc(hmac(sha384),cbc(des))");
2047  		break;
2048  	case 188:
2049  		ret += tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))");
2050  		break;
2051  	case 189:
2052  		ret += tcrypt_test("authenc(hmac(sha512),cbc(des))");
2053  		break;
2054  	case 190:
2055  		ret += tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))");
2056  		break;
2057  	case 191:
2058  		ret += tcrypt_test("ecb(sm4)");
2059  		ret += tcrypt_test("cbc(sm4)");
2060  		ret += tcrypt_test("cfb(sm4)");
2061  		ret += tcrypt_test("ctr(sm4)");
2062  		break;
2063  	case 200:
2064  		test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
2065  				speed_template_16_24_32);
2066  		test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
2067  				speed_template_16_24_32);
2068  		test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
2069  				speed_template_16_24_32);
2070  		test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
2071  				speed_template_16_24_32);
2072  		test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
2073  				speed_template_32_40_48);
2074  		test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
2075  				speed_template_32_40_48);
2076  		test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
2077  				speed_template_32_64);
2078  		test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
2079  				speed_template_32_64);
2080  		test_cipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
2081  				speed_template_16_24_32);
2082  		test_cipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
2083  				speed_template_16_24_32);
2084  		test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
2085  				speed_template_16_24_32);
2086  		test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
2087  				speed_template_16_24_32);
2088  		test_cipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
2089  				speed_template_16_24_32);
2090  		test_cipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
2091  				speed_template_16_24_32);
2092  		break;
2093  
2094  	case 201:
2095  		test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
2096  				des3_speed_template, DES3_SPEED_VECTORS,
2097  				speed_template_24);
2098  		test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
2099  				des3_speed_template, DES3_SPEED_VECTORS,
2100  				speed_template_24);
2101  		test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
2102  				des3_speed_template, DES3_SPEED_VECTORS,
2103  				speed_template_24);
2104  		test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
2105  				des3_speed_template, DES3_SPEED_VECTORS,
2106  				speed_template_24);
2107  		test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec,
2108  				des3_speed_template, DES3_SPEED_VECTORS,
2109  				speed_template_24);
2110  		test_cipher_speed("ctr(des3_ede)", DECRYPT, sec,
2111  				des3_speed_template, DES3_SPEED_VECTORS,
2112  				speed_template_24);
2113  		break;
2114  
2115  	case 202:
2116  		test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2117  				speed_template_16_24_32);
2118  		test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2119  				speed_template_16_24_32);
2120  		test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2121  				speed_template_16_24_32);
2122  		test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2123  				speed_template_16_24_32);
2124  		test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2125  				speed_template_16_24_32);
2126  		test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2127  				speed_template_16_24_32);
2128  		test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2129  				speed_template_32_40_48);
2130  		test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2131  				speed_template_32_40_48);
2132  		test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2133  				speed_template_32_48_64);
2134  		test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2135  				speed_template_32_48_64);
2136  		break;
2137  
2138  	case 203:
2139  		test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2140  				  speed_template_8_32);
2141  		test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2142  				  speed_template_8_32);
2143  		test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2144  				  speed_template_8_32);
2145  		test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2146  				  speed_template_8_32);
2147  		test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2148  				  speed_template_8_32);
2149  		test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2150  				  speed_template_8_32);
2151  		break;
2152  
2153  	case 204:
2154  		test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
2155  				  speed_template_8);
2156  		test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
2157  				  speed_template_8);
2158  		test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
2159  				  speed_template_8);
2160  		test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
2161  				  speed_template_8);
2162  		break;
2163  
2164  	case 205:
2165  		test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2166  				speed_template_16_24_32);
2167  		test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2168  				speed_template_16_24_32);
2169  		test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2170  				speed_template_16_24_32);
2171  		test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2172  				speed_template_16_24_32);
2173  		test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2174  				speed_template_16_24_32);
2175  		test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2176  				speed_template_16_24_32);
2177  		test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2178  				speed_template_32_40_48);
2179  		test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2180  				speed_template_32_40_48);
2181  		test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2182  				speed_template_32_48_64);
2183  		test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2184  				speed_template_32_48_64);
2185  		break;
2186  
2187  	case 207:
2188  		test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
2189  				  speed_template_16_32);
2190  		test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
2191  				  speed_template_16_32);
2192  		test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2193  				  speed_template_16_32);
2194  		test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2195  				  speed_template_16_32);
2196  		test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2197  				  speed_template_16_32);
2198  		test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2199  				  speed_template_16_32);
2200  		test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2201  				  speed_template_32_48);
2202  		test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2203  				  speed_template_32_48);
2204  		test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2205  				  speed_template_32_64);
2206  		test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2207  				  speed_template_32_64);
2208  		break;
2209  
2210  	case 208:
2211  		test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2212  				  speed_template_8);
2213  		break;
2214  
2215  	case 209:
2216  		test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2217  				  speed_template_8_16);
2218  		test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2219  				  speed_template_8_16);
2220  		test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2221  				  speed_template_8_16);
2222  		test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2223  				  speed_template_8_16);
2224  		test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2225  				  speed_template_8_16);
2226  		test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2227  				  speed_template_8_16);
2228  		break;
2229  
2230  	case 210:
2231  		test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2232  				  speed_template_16_32);
2233  		test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2234  				  speed_template_16_32);
2235  		test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2236  				  speed_template_16_32);
2237  		test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2238  				  speed_template_16_32);
2239  		test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2240  				  speed_template_16_32);
2241  		test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2242  				  speed_template_16_32);
2243  		test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2244  				  speed_template_32_48);
2245  		test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2246  				  speed_template_32_48);
2247  		test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2248  				  speed_template_32_64);
2249  		test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2250  				  speed_template_32_64);
2251  		break;
2252  
2253  	case 211:
2254  		test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec,
2255  				NULL, 0, 16, 16, aead_speed_template_20);
2256  		test_aead_speed("gcm(aes)", ENCRYPT, sec,
2257  				NULL, 0, 16, 8, speed_template_16_24_32);
2258  		test_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec,
2259  				NULL, 0, 16, 16, aead_speed_template_20);
2260  		test_aead_speed("gcm(aes)", DECRYPT, sec,
2261  				NULL, 0, 16, 8, speed_template_16_24_32);
2262  		break;
2263  
2264  	case 212:
2265  		test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec,
2266  				NULL, 0, 16, 16, aead_speed_template_19);
2267  		test_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec,
2268  				NULL, 0, 16, 16, aead_speed_template_19);
2269  		break;
2270  
2271  	case 213:
2272  		test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, sec,
2273  				NULL, 0, 16, 8, aead_speed_template_36);
2274  		test_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT, sec,
2275  				NULL, 0, 16, 8, aead_speed_template_36);
2276  		break;
2277  
2278  	case 214:
2279  		test_cipher_speed("chacha20", ENCRYPT, sec, NULL, 0,
2280  				  speed_template_32);
2281  		break;
2282  
2283  	case 215:
2284  		test_mb_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec, NULL,
2285  				   0, 16, 16, aead_speed_template_20, num_mb);
2286  		test_mb_aead_speed("gcm(aes)", ENCRYPT, sec, NULL, 0, 16, 8,
2287  				   speed_template_16_24_32, num_mb);
2288  		test_mb_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec, NULL,
2289  				   0, 16, 16, aead_speed_template_20, num_mb);
2290  		test_mb_aead_speed("gcm(aes)", DECRYPT, sec, NULL, 0, 16, 8,
2291  				   speed_template_16_24_32, num_mb);
2292  		break;
2293  
2294  	case 216:
2295  		test_mb_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec, NULL, 0,
2296  				   16, 16, aead_speed_template_19, num_mb);
2297  		test_mb_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec, NULL, 0,
2298  				   16, 16, aead_speed_template_19, num_mb);
2299  		break;
2300  
2301  	case 217:
2302  		test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT,
2303  				   sec, NULL, 0, 16, 8, aead_speed_template_36,
2304  				   num_mb);
2305  		test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT,
2306  				   sec, NULL, 0, 16, 8, aead_speed_template_36,
2307  				   num_mb);
2308  		break;
2309  
2310  	case 218:
2311  		test_cipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0,
2312  				speed_template_16);
2313  		test_cipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0,
2314  				speed_template_16);
2315  		test_cipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0,
2316  				speed_template_16);
2317  		test_cipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0,
2318  				speed_template_16);
2319  		test_cipher_speed("cfb(sm4)", ENCRYPT, sec, NULL, 0,
2320  				speed_template_16);
2321  		test_cipher_speed("cfb(sm4)", DECRYPT, sec, NULL, 0,
2322  				speed_template_16);
2323  		test_cipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0,
2324  				speed_template_16);
2325  		test_cipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0,
2326  				speed_template_16);
2327  		break;
2328  
2329  	case 219:
2330  		test_cipher_speed("adiantum(xchacha12,aes)", ENCRYPT, sec, NULL,
2331  				  0, speed_template_32);
2332  		test_cipher_speed("adiantum(xchacha12,aes)", DECRYPT, sec, NULL,
2333  				  0, speed_template_32);
2334  		test_cipher_speed("adiantum(xchacha20,aes)", ENCRYPT, sec, NULL,
2335  				  0, speed_template_32);
2336  		test_cipher_speed("adiantum(xchacha20,aes)", DECRYPT, sec, NULL,
2337  				  0, speed_template_32);
2338  		break;
2339  
2340  	case 220:
2341  		test_acipher_speed("essiv(cbc(aes),sha256)",
2342  				  ENCRYPT, sec, NULL, 0,
2343  				  speed_template_16_24_32);
2344  		test_acipher_speed("essiv(cbc(aes),sha256)",
2345  				  DECRYPT, sec, NULL, 0,
2346  				  speed_template_16_24_32);
2347  		break;
2348  
2349  	case 221:
2350  		test_aead_speed("aegis128", ENCRYPT, sec,
2351  				NULL, 0, 16, 8, speed_template_16);
2352  		test_aead_speed("aegis128", DECRYPT, sec,
2353  				NULL, 0, 16, 8, speed_template_16);
2354  		break;
2355  
2356  	case 222:
2357  		test_aead_speed("gcm(sm4)", ENCRYPT, sec,
2358  				NULL, 0, 16, 8, speed_template_16);
2359  		test_aead_speed("gcm(sm4)", DECRYPT, sec,
2360  				NULL, 0, 16, 8, speed_template_16);
2361  		break;
2362  
2363  	case 223:
2364  		test_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec,
2365  				NULL, 0, 16, 16, aead_speed_template_19);
2366  		test_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec,
2367  				NULL, 0, 16, 16, aead_speed_template_19);
2368  		break;
2369  
2370  	case 224:
2371  		test_mb_aead_speed("gcm(sm4)", ENCRYPT, sec, NULL, 0, 16, 8,
2372  				   speed_template_16, num_mb);
2373  		test_mb_aead_speed("gcm(sm4)", DECRYPT, sec, NULL, 0, 16, 8,
2374  				   speed_template_16, num_mb);
2375  		break;
2376  
2377  	case 225:
2378  		test_mb_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec, NULL, 0,
2379  				   16, 16, aead_speed_template_19, num_mb);
2380  		test_mb_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec, NULL, 0,
2381  				   16, 16, aead_speed_template_19, num_mb);
2382  		break;
2383  
2384  	case 300:
2385  		if (alg) {
2386  			test_hash_speed(alg, sec, generic_hash_speed_template);
2387  			break;
2388  		}
2389  		fallthrough;
2390  	case 301:
2391  		test_hash_speed("md4", sec, generic_hash_speed_template);
2392  		if (mode > 300 && mode < 400) break;
2393  		fallthrough;
2394  	case 302:
2395  		test_hash_speed("md5", sec, generic_hash_speed_template);
2396  		if (mode > 300 && mode < 400) break;
2397  		fallthrough;
2398  	case 303:
2399  		test_hash_speed("sha1", sec, generic_hash_speed_template);
2400  		if (mode > 300 && mode < 400) break;
2401  		fallthrough;
2402  	case 304:
2403  		test_hash_speed("sha256", sec, generic_hash_speed_template);
2404  		if (mode > 300 && mode < 400) break;
2405  		fallthrough;
2406  	case 305:
2407  		test_hash_speed("sha384", sec, generic_hash_speed_template);
2408  		if (mode > 300 && mode < 400) break;
2409  		fallthrough;
2410  	case 306:
2411  		test_hash_speed("sha512", sec, generic_hash_speed_template);
2412  		if (mode > 300 && mode < 400) break;
2413  		fallthrough;
2414  	case 307:
2415  		test_hash_speed("wp256", sec, generic_hash_speed_template);
2416  		if (mode > 300 && mode < 400) break;
2417  		fallthrough;
2418  	case 308:
2419  		test_hash_speed("wp384", sec, generic_hash_speed_template);
2420  		if (mode > 300 && mode < 400) break;
2421  		fallthrough;
2422  	case 309:
2423  		test_hash_speed("wp512", sec, generic_hash_speed_template);
2424  		if (mode > 300 && mode < 400) break;
2425  		fallthrough;
2426  	case 313:
2427  		test_hash_speed("sha224", sec, generic_hash_speed_template);
2428  		if (mode > 300 && mode < 400) break;
2429  		fallthrough;
2430  	case 314:
2431  		test_hash_speed("xxhash64", sec, generic_hash_speed_template);
2432  		if (mode > 300 && mode < 400) break;
2433  		fallthrough;
2434  	case 315:
2435  		test_hash_speed("rmd160", sec, generic_hash_speed_template);
2436  		if (mode > 300 && mode < 400) break;
2437  		fallthrough;
2438  	case 316:
2439  		test_hash_speed("blake2s-256", sec, generic_hash_speed_template);
2440  		if (mode > 300 && mode < 400) break;
2441  		fallthrough;
2442  	case 317:
2443  		test_hash_speed("blake2b-512", sec, generic_hash_speed_template);
2444  		if (mode > 300 && mode < 400) break;
2445  		fallthrough;
2446  	case 318:
2447  		klen = 16;
2448  		test_hash_speed("ghash", sec, generic_hash_speed_template);
2449  		if (mode > 300 && mode < 400) break;
2450  		fallthrough;
2451  	case 319:
2452  		test_hash_speed("crc32c", sec, generic_hash_speed_template);
2453  		if (mode > 300 && mode < 400) break;
2454  		fallthrough;
2455  	case 320:
2456  		test_hash_speed("crct10dif", sec, generic_hash_speed_template);
2457  		if (mode > 300 && mode < 400) break;
2458  		fallthrough;
2459  	case 321:
2460  		test_hash_speed("poly1305", sec, poly1305_speed_template);
2461  		if (mode > 300 && mode < 400) break;
2462  		fallthrough;
2463  	case 322:
2464  		test_hash_speed("sha3-224", sec, generic_hash_speed_template);
2465  		if (mode > 300 && mode < 400) break;
2466  		fallthrough;
2467  	case 323:
2468  		test_hash_speed("sha3-256", sec, generic_hash_speed_template);
2469  		if (mode > 300 && mode < 400) break;
2470  		fallthrough;
2471  	case 324:
2472  		test_hash_speed("sha3-384", sec, generic_hash_speed_template);
2473  		if (mode > 300 && mode < 400) break;
2474  		fallthrough;
2475  	case 325:
2476  		test_hash_speed("sha3-512", sec, generic_hash_speed_template);
2477  		if (mode > 300 && mode < 400) break;
2478  		fallthrough;
2479  	case 326:
2480  		test_hash_speed("sm3", sec, generic_hash_speed_template);
2481  		if (mode > 300 && mode < 400) break;
2482  		fallthrough;
2483  	case 327:
2484  		test_hash_speed("streebog256", sec,
2485  				generic_hash_speed_template);
2486  		if (mode > 300 && mode < 400) break;
2487  		fallthrough;
2488  	case 328:
2489  		test_hash_speed("streebog512", sec,
2490  				generic_hash_speed_template);
2491  		if (mode > 300 && mode < 400) break;
2492  		fallthrough;
2493  	case 399:
2494  		break;
2495  
2496  	case 400:
2497  		if (alg) {
2498  			test_ahash_speed(alg, sec, generic_hash_speed_template);
2499  			break;
2500  		}
2501  		fallthrough;
2502  	case 401:
2503  		test_ahash_speed("md4", sec, generic_hash_speed_template);
2504  		if (mode > 400 && mode < 500) break;
2505  		fallthrough;
2506  	case 402:
2507  		test_ahash_speed("md5", sec, generic_hash_speed_template);
2508  		if (mode > 400 && mode < 500) break;
2509  		fallthrough;
2510  	case 403:
2511  		test_ahash_speed("sha1", sec, generic_hash_speed_template);
2512  		if (mode > 400 && mode < 500) break;
2513  		fallthrough;
2514  	case 404:
2515  		test_ahash_speed("sha256", sec, generic_hash_speed_template);
2516  		if (mode > 400 && mode < 500) break;
2517  		fallthrough;
2518  	case 405:
2519  		test_ahash_speed("sha384", sec, generic_hash_speed_template);
2520  		if (mode > 400 && mode < 500) break;
2521  		fallthrough;
2522  	case 406:
2523  		test_ahash_speed("sha512", sec, generic_hash_speed_template);
2524  		if (mode > 400 && mode < 500) break;
2525  		fallthrough;
2526  	case 407:
2527  		test_ahash_speed("wp256", sec, generic_hash_speed_template);
2528  		if (mode > 400 && mode < 500) break;
2529  		fallthrough;
2530  	case 408:
2531  		test_ahash_speed("wp384", sec, generic_hash_speed_template);
2532  		if (mode > 400 && mode < 500) break;
2533  		fallthrough;
2534  	case 409:
2535  		test_ahash_speed("wp512", sec, generic_hash_speed_template);
2536  		if (mode > 400 && mode < 500) break;
2537  		fallthrough;
2538  	case 413:
2539  		test_ahash_speed("sha224", sec, generic_hash_speed_template);
2540  		if (mode > 400 && mode < 500) break;
2541  		fallthrough;
2542  	case 414:
2543  		test_ahash_speed("xxhash64", sec, generic_hash_speed_template);
2544  		if (mode > 400 && mode < 500) break;
2545  		fallthrough;
2546  	case 415:
2547  		test_ahash_speed("rmd160", sec, generic_hash_speed_template);
2548  		if (mode > 400 && mode < 500) break;
2549  		fallthrough;
2550  	case 416:
2551  		test_ahash_speed("blake2s-256", sec, generic_hash_speed_template);
2552  		if (mode > 400 && mode < 500) break;
2553  		fallthrough;
2554  	case 417:
2555  		test_ahash_speed("blake2b-512", sec, generic_hash_speed_template);
2556  		if (mode > 400 && mode < 500) break;
2557  		fallthrough;
2558  	case 418:
2559  		test_ahash_speed("sha3-224", sec, generic_hash_speed_template);
2560  		if (mode > 400 && mode < 500) break;
2561  		fallthrough;
2562  	case 419:
2563  		test_ahash_speed("sha3-256", sec, generic_hash_speed_template);
2564  		if (mode > 400 && mode < 500) break;
2565  		fallthrough;
2566  	case 420:
2567  		test_ahash_speed("sha3-384", sec, generic_hash_speed_template);
2568  		if (mode > 400 && mode < 500) break;
2569  		fallthrough;
2570  	case 421:
2571  		test_ahash_speed("sha3-512", sec, generic_hash_speed_template);
2572  		if (mode > 400 && mode < 500) break;
2573  		fallthrough;
2574  	case 422:
2575  		test_mb_ahash_speed("sha1", sec, generic_hash_speed_template,
2576  				    num_mb);
2577  		if (mode > 400 && mode < 500) break;
2578  		fallthrough;
2579  	case 423:
2580  		test_mb_ahash_speed("sha256", sec, generic_hash_speed_template,
2581  				    num_mb);
2582  		if (mode > 400 && mode < 500) break;
2583  		fallthrough;
2584  	case 424:
2585  		test_mb_ahash_speed("sha512", sec, generic_hash_speed_template,
2586  				    num_mb);
2587  		if (mode > 400 && mode < 500) break;
2588  		fallthrough;
2589  	case 425:
2590  		test_mb_ahash_speed("sm3", sec, generic_hash_speed_template,
2591  				    num_mb);
2592  		if (mode > 400 && mode < 500) break;
2593  		fallthrough;
2594  	case 426:
2595  		test_mb_ahash_speed("streebog256", sec,
2596  				    generic_hash_speed_template, num_mb);
2597  		if (mode > 400 && mode < 500) break;
2598  		fallthrough;
2599  	case 427:
2600  		test_mb_ahash_speed("streebog512", sec,
2601  				    generic_hash_speed_template, num_mb);
2602  		if (mode > 400 && mode < 500) break;
2603  		fallthrough;
2604  	case 499:
2605  		break;
2606  
2607  	case 500:
2608  		test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
2609  				   speed_template_16_24_32);
2610  		test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
2611  				   speed_template_16_24_32);
2612  		test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
2613  				   speed_template_16_24_32);
2614  		test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
2615  				   speed_template_16_24_32);
2616  		test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
2617  				   speed_template_32_40_48);
2618  		test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
2619  				   speed_template_32_40_48);
2620  		test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
2621  				   speed_template_32_64);
2622  		test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
2623  				   speed_template_32_64);
2624  		test_acipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
2625  				   speed_template_16_24_32);
2626  		test_acipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
2627  				   speed_template_16_24_32);
2628  		test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
2629  				   speed_template_16_24_32);
2630  		test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
2631  				   speed_template_16_24_32);
2632  		test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
2633  				   speed_template_16_24_32);
2634  		test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
2635  				   speed_template_16_24_32);
2636  		test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
2637  				   speed_template_16_24_32);
2638  		test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
2639  				   speed_template_16_24_32);
2640  		test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0,
2641  				   speed_template_20_28_36);
2642  		test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0,
2643  				   speed_template_20_28_36);
2644  		break;
2645  
2646  	case 501:
2647  		test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
2648  				   des3_speed_template, DES3_SPEED_VECTORS,
2649  				   speed_template_24);
2650  		test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
2651  				   des3_speed_template, DES3_SPEED_VECTORS,
2652  				   speed_template_24);
2653  		test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
2654  				   des3_speed_template, DES3_SPEED_VECTORS,
2655  				   speed_template_24);
2656  		test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
2657  				   des3_speed_template, DES3_SPEED_VECTORS,
2658  				   speed_template_24);
2659  		test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec,
2660  				   des3_speed_template, DES3_SPEED_VECTORS,
2661  				   speed_template_24);
2662  		test_acipher_speed("cfb(des3_ede)", DECRYPT, sec,
2663  				   des3_speed_template, DES3_SPEED_VECTORS,
2664  				   speed_template_24);
2665  		test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec,
2666  				   des3_speed_template, DES3_SPEED_VECTORS,
2667  				   speed_template_24);
2668  		test_acipher_speed("ofb(des3_ede)", DECRYPT, sec,
2669  				   des3_speed_template, DES3_SPEED_VECTORS,
2670  				   speed_template_24);
2671  		break;
2672  
2673  	case 502:
2674  		test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
2675  				   speed_template_8);
2676  		test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
2677  				   speed_template_8);
2678  		test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
2679  				   speed_template_8);
2680  		test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
2681  				   speed_template_8);
2682  		test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
2683  				   speed_template_8);
2684  		test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
2685  				   speed_template_8);
2686  		test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
2687  				   speed_template_8);
2688  		test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
2689  				   speed_template_8);
2690  		break;
2691  
2692  	case 503:
2693  		test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
2694  				   speed_template_16_32);
2695  		test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
2696  				   speed_template_16_32);
2697  		test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2698  				   speed_template_16_32);
2699  		test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2700  				   speed_template_16_32);
2701  		test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2702  				   speed_template_16_32);
2703  		test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2704  				   speed_template_16_32);
2705  		test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2706  				   speed_template_32_48);
2707  		test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2708  				   speed_template_32_48);
2709  		test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2710  				   speed_template_32_64);
2711  		test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2712  				   speed_template_32_64);
2713  		break;
2714  
2715  	case 504:
2716  		test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2717  				   speed_template_16_24_32);
2718  		test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2719  				   speed_template_16_24_32);
2720  		test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2721  				   speed_template_16_24_32);
2722  		test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2723  				   speed_template_16_24_32);
2724  		test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2725  				   speed_template_16_24_32);
2726  		test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2727  				   speed_template_16_24_32);
2728  		test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2729  				   speed_template_32_40_48);
2730  		test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2731  				   speed_template_32_40_48);
2732  		test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2733  				   speed_template_32_48_64);
2734  		test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2735  				   speed_template_32_48_64);
2736  		break;
2737  
2738  	case 505:
2739  		test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2740  				   speed_template_8);
2741  		break;
2742  
2743  	case 506:
2744  		test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2745  				   speed_template_8_16);
2746  		test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2747  				   speed_template_8_16);
2748  		test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2749  				   speed_template_8_16);
2750  		test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2751  				   speed_template_8_16);
2752  		test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2753  				   speed_template_8_16);
2754  		test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2755  				   speed_template_8_16);
2756  		break;
2757  
2758  	case 507:
2759  		test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2760  				   speed_template_16_32);
2761  		test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2762  				   speed_template_16_32);
2763  		test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2764  				   speed_template_16_32);
2765  		test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2766  				   speed_template_16_32);
2767  		test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2768  				   speed_template_16_32);
2769  		test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2770  				   speed_template_16_32);
2771  		test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2772  				   speed_template_32_48);
2773  		test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2774  				   speed_template_32_48);
2775  		test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2776  				   speed_template_32_64);
2777  		test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2778  				   speed_template_32_64);
2779  		break;
2780  
2781  	case 508:
2782  		test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2783  				   speed_template_16_32);
2784  		test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2785  				   speed_template_16_32);
2786  		test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2787  				   speed_template_16_32);
2788  		test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2789  				   speed_template_16_32);
2790  		test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2791  				   speed_template_16_32);
2792  		test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2793  				   speed_template_16_32);
2794  		test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2795  				   speed_template_32_48);
2796  		test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2797  				   speed_template_32_48);
2798  		test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2799  				   speed_template_32_64);
2800  		test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2801  				   speed_template_32_64);
2802  		break;
2803  
2804  	case 509:
2805  		test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2806  				   speed_template_8_32);
2807  		test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2808  				   speed_template_8_32);
2809  		test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2810  				   speed_template_8_32);
2811  		test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2812  				   speed_template_8_32);
2813  		test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2814  				   speed_template_8_32);
2815  		test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2816  				   speed_template_8_32);
2817  		break;
2818  
2819  	case 518:
2820  		test_acipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0,
2821  				speed_template_16);
2822  		test_acipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0,
2823  				speed_template_16);
2824  		test_acipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0,
2825  				speed_template_16);
2826  		test_acipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0,
2827  				speed_template_16);
2828  		test_acipher_speed("cfb(sm4)", ENCRYPT, sec, NULL, 0,
2829  				speed_template_16);
2830  		test_acipher_speed("cfb(sm4)", DECRYPT, sec, NULL, 0,
2831  				speed_template_16);
2832  		test_acipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0,
2833  				speed_template_16);
2834  		test_acipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0,
2835  				speed_template_16);
2836  		break;
2837  
2838  	case 600:
2839  		test_mb_skcipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
2840  				       speed_template_16_24_32, num_mb);
2841  		test_mb_skcipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
2842  				       speed_template_16_24_32, num_mb);
2843  		test_mb_skcipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
2844  				       speed_template_16_24_32, num_mb);
2845  		test_mb_skcipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
2846  				       speed_template_16_24_32, num_mb);
2847  		test_mb_skcipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
2848  				       speed_template_32_40_48, num_mb);
2849  		test_mb_skcipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
2850  				       speed_template_32_40_48, num_mb);
2851  		test_mb_skcipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
2852  				       speed_template_32_64, num_mb);
2853  		test_mb_skcipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
2854  				       speed_template_32_64, num_mb);
2855  		test_mb_skcipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
2856  				       speed_template_16_24_32, num_mb);
2857  		test_mb_skcipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
2858  				       speed_template_16_24_32, num_mb);
2859  		test_mb_skcipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
2860  				       speed_template_16_24_32, num_mb);
2861  		test_mb_skcipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
2862  				       speed_template_16_24_32, num_mb);
2863  		test_mb_skcipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
2864  				       speed_template_16_24_32, num_mb);
2865  		test_mb_skcipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
2866  				       speed_template_16_24_32, num_mb);
2867  		test_mb_skcipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
2868  				       speed_template_16_24_32, num_mb);
2869  		test_mb_skcipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
2870  				       speed_template_16_24_32, num_mb);
2871  		test_mb_skcipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL,
2872  				       0, speed_template_20_28_36, num_mb);
2873  		test_mb_skcipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL,
2874  				       0, speed_template_20_28_36, num_mb);
2875  		break;
2876  
2877  	case 601:
2878  		test_mb_skcipher_speed("ecb(des3_ede)", ENCRYPT, sec,
2879  				       des3_speed_template, DES3_SPEED_VECTORS,
2880  				       speed_template_24, num_mb);
2881  		test_mb_skcipher_speed("ecb(des3_ede)", DECRYPT, sec,
2882  				       des3_speed_template, DES3_SPEED_VECTORS,
2883  				       speed_template_24, num_mb);
2884  		test_mb_skcipher_speed("cbc(des3_ede)", ENCRYPT, sec,
2885  				       des3_speed_template, DES3_SPEED_VECTORS,
2886  				       speed_template_24, num_mb);
2887  		test_mb_skcipher_speed("cbc(des3_ede)", DECRYPT, sec,
2888  				       des3_speed_template, DES3_SPEED_VECTORS,
2889  				       speed_template_24, num_mb);
2890  		test_mb_skcipher_speed("cfb(des3_ede)", ENCRYPT, sec,
2891  				       des3_speed_template, DES3_SPEED_VECTORS,
2892  				       speed_template_24, num_mb);
2893  		test_mb_skcipher_speed("cfb(des3_ede)", DECRYPT, sec,
2894  				       des3_speed_template, DES3_SPEED_VECTORS,
2895  				       speed_template_24, num_mb);
2896  		test_mb_skcipher_speed("ofb(des3_ede)", ENCRYPT, sec,
2897  				       des3_speed_template, DES3_SPEED_VECTORS,
2898  				       speed_template_24, num_mb);
2899  		test_mb_skcipher_speed("ofb(des3_ede)", DECRYPT, sec,
2900  				       des3_speed_template, DES3_SPEED_VECTORS,
2901  				       speed_template_24, num_mb);
2902  		break;
2903  
2904  	case 602:
2905  		test_mb_skcipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
2906  				       speed_template_8, num_mb);
2907  		test_mb_skcipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
2908  				       speed_template_8, num_mb);
2909  		test_mb_skcipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
2910  				       speed_template_8, num_mb);
2911  		test_mb_skcipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
2912  				       speed_template_8, num_mb);
2913  		test_mb_skcipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
2914  				       speed_template_8, num_mb);
2915  		test_mb_skcipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
2916  				       speed_template_8, num_mb);
2917  		test_mb_skcipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
2918  				       speed_template_8, num_mb);
2919  		test_mb_skcipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
2920  				       speed_template_8, num_mb);
2921  		break;
2922  
2923  	case 603:
2924  		test_mb_skcipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
2925  				       speed_template_16_32, num_mb);
2926  		test_mb_skcipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
2927  				       speed_template_16_32, num_mb);
2928  		test_mb_skcipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2929  				       speed_template_16_32, num_mb);
2930  		test_mb_skcipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2931  				       speed_template_16_32, num_mb);
2932  		test_mb_skcipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2933  				       speed_template_16_32, num_mb);
2934  		test_mb_skcipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2935  				       speed_template_16_32, num_mb);
2936  		test_mb_skcipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2937  				       speed_template_32_48, num_mb);
2938  		test_mb_skcipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2939  				       speed_template_32_48, num_mb);
2940  		test_mb_skcipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2941  				       speed_template_32_64, num_mb);
2942  		test_mb_skcipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2943  				       speed_template_32_64, num_mb);
2944  		break;
2945  
2946  	case 604:
2947  		test_mb_skcipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2948  				       speed_template_16_24_32, num_mb);
2949  		test_mb_skcipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2950  				       speed_template_16_24_32, num_mb);
2951  		test_mb_skcipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2952  				       speed_template_16_24_32, num_mb);
2953  		test_mb_skcipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2954  				       speed_template_16_24_32, num_mb);
2955  		test_mb_skcipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2956  				       speed_template_16_24_32, num_mb);
2957  		test_mb_skcipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2958  				       speed_template_16_24_32, num_mb);
2959  		test_mb_skcipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2960  				       speed_template_32_40_48, num_mb);
2961  		test_mb_skcipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2962  				       speed_template_32_40_48, num_mb);
2963  		test_mb_skcipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2964  				       speed_template_32_48_64, num_mb);
2965  		test_mb_skcipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2966  				       speed_template_32_48_64, num_mb);
2967  		break;
2968  
2969  	case 605:
2970  		test_mb_skcipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2971  				       speed_template_8, num_mb);
2972  		break;
2973  
2974  	case 606:
2975  		test_mb_skcipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2976  				       speed_template_8_16, num_mb);
2977  		test_mb_skcipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2978  				       speed_template_8_16, num_mb);
2979  		test_mb_skcipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2980  				       speed_template_8_16, num_mb);
2981  		test_mb_skcipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2982  				       speed_template_8_16, num_mb);
2983  		test_mb_skcipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2984  				       speed_template_8_16, num_mb);
2985  		test_mb_skcipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2986  				       speed_template_8_16, num_mb);
2987  		break;
2988  
2989  	case 607:
2990  		test_mb_skcipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2991  				       speed_template_16_32, num_mb);
2992  		test_mb_skcipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2993  				       speed_template_16_32, num_mb);
2994  		test_mb_skcipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2995  				       speed_template_16_32, num_mb);
2996  		test_mb_skcipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2997  				       speed_template_16_32, num_mb);
2998  		test_mb_skcipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2999  				       speed_template_16_32, num_mb);
3000  		test_mb_skcipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
3001  				       speed_template_16_32, num_mb);
3002  		test_mb_skcipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
3003  				       speed_template_32_48, num_mb);
3004  		test_mb_skcipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
3005  				       speed_template_32_48, num_mb);
3006  		test_mb_skcipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
3007  				       speed_template_32_64, num_mb);
3008  		test_mb_skcipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
3009  				       speed_template_32_64, num_mb);
3010  		break;
3011  
3012  	case 608:
3013  		test_mb_skcipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
3014  				       speed_template_16_32, num_mb);
3015  		test_mb_skcipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
3016  				       speed_template_16_32, num_mb);
3017  		test_mb_skcipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
3018  				       speed_template_16_32, num_mb);
3019  		test_mb_skcipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
3020  				       speed_template_16_32, num_mb);
3021  		test_mb_skcipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
3022  				       speed_template_16_32, num_mb);
3023  		test_mb_skcipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
3024  				       speed_template_16_32, num_mb);
3025  		test_mb_skcipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
3026  				       speed_template_32_48, num_mb);
3027  		test_mb_skcipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
3028  				       speed_template_32_48, num_mb);
3029  		test_mb_skcipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
3030  				       speed_template_32_64, num_mb);
3031  		test_mb_skcipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
3032  				       speed_template_32_64, num_mb);
3033  		break;
3034  
3035  	case 609:
3036  		test_mb_skcipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
3037  				       speed_template_8_32, num_mb);
3038  		test_mb_skcipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
3039  				       speed_template_8_32, num_mb);
3040  		test_mb_skcipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
3041  				       speed_template_8_32, num_mb);
3042  		test_mb_skcipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
3043  				       speed_template_8_32, num_mb);
3044  		test_mb_skcipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
3045  				       speed_template_8_32, num_mb);
3046  		test_mb_skcipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
3047  				       speed_template_8_32, num_mb);
3048  		break;
3049  
3050  	case 1000:
3051  		test_available();
3052  		break;
3053  	}
3054  
3055  	return ret;
3056  }
3057  
3058  static int __init tcrypt_mod_init(void)
3059  {
3060  	int err = -ENOMEM;
3061  	int i;
3062  
3063  	for (i = 0; i < TVMEMSIZE; i++) {
3064  		tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
3065  		if (!tvmem[i])
3066  			goto err_free_tv;
3067  	}
3068  
3069  	err = do_test(alg, type, mask, mode, num_mb);
3070  
3071  	if (err) {
3072  		printk(KERN_ERR "tcrypt: one or more tests failed!\n");
3073  		goto err_free_tv;
3074  	} else {
3075  		pr_debug("all tests passed\n");
3076  	}
3077  
3078  	/* We intentionaly return -EAGAIN to prevent keeping the module,
3079  	 * unless we're running in fips mode. It does all its work from
3080  	 * init() and doesn't offer any runtime functionality, but in
3081  	 * the fips case, checking for a successful load is helpful.
3082  	 * => we don't need it in the memory, do we?
3083  	 *                                        -- mludvig
3084  	 */
3085  	if (!fips_enabled)
3086  		err = -EAGAIN;
3087  
3088  err_free_tv:
3089  	for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
3090  		free_page((unsigned long)tvmem[i]);
3091  
3092  	return err;
3093  }
3094  
3095  /*
3096   * If an init function is provided, an exit function must also be provided
3097   * to allow module unload.
3098   */
3099  static void __exit tcrypt_mod_fini(void) { }
3100  
3101  late_initcall(tcrypt_mod_init);
3102  module_exit(tcrypt_mod_fini);
3103  
3104  module_param(alg, charp, 0);
3105  module_param(type, uint, 0);
3106  module_param(mask, uint, 0);
3107  module_param(mode, int, 0);
3108  module_param(sec, uint, 0);
3109  MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
3110  		      "(defaults to zero which uses CPU cycles instead)");
3111  module_param(num_mb, uint, 0000);
3112  MODULE_PARM_DESC(num_mb, "Number of concurrent requests to be used in mb speed tests (defaults to 8)");
3113  module_param(klen, uint, 0);
3114  MODULE_PARM_DESC(klen, "Key length (defaults to 0)");
3115  
3116  MODULE_LICENSE("GPL");
3117  MODULE_DESCRIPTION("Quick & dirty crypto testing module");
3118  MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
3119