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

source code of linux/crypto/tcrypt.c