projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'riscv-for-linus-6.4-mw1' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-block.git] / crypto / tcrypt.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
ef2736fc 2/*
1da177e4
LT		 3 * Quick & dirty crypto testing module.
4 *
5 * This will only exist until we have a better testing mechanism
6 * (e.g. a char device).
7 *
8 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
9 * Copyright (c) 2002 Jean-Francois Dive <jef@linuxbe.org>
e3a4ea4f 10 * Copyright (c) 2007 Nokia Siemens Networks
1da177e4 11 *
69435b94
AH		 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.
1da177e4
LT		 18 */
19
76512f2d
RV		 20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
1ce5a04d 22#include <crypto/aead.h>
18e33e6d 23#include <crypto/hash.h>
7166e589 24#include <crypto/skcipher.h>
cba83564 25#include <linux/err.h>
daf0944c 26#include <linux/fips.h>
1da177e4 27#include <linux/init.h>
01f727cd
HX		 28#include <linux/interrupt.h>
29#include <linux/jiffies.h>
30#include <linux/kernel.h>
1da177e4 31#include <linux/module.h>
01f727cd 32#include <linux/moduleparam.h>
378f058c 33#include <linux/scatterlist.h>
01f727cd 34#include <linux/slab.h>
1da177e4 35#include <linux/string.h>
6a17944c 36#include <linux/timex.h>
01f727cd
HX		 37
38#include "internal.h"
1da177e4
LT		 39#include "tcrypt.h"
40
41/*
f139cfa7 42 * Need slab memory for testing (size in number of pages).
1da177e4 43 */
f139cfa7 44#define TVMEMSIZE 4
1da177e4
LT		 45
46/*
da7f033d 47* Used by test_cipher_speed()
1da177e4
LT		 48*/
49#define ENCRYPT 1
50#define DECRYPT 0
1da177e4 51
f074f7b1
HG		 52#define MAX_DIGEST_SIZE 64
53
263a8df0
LC		 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
ebfd9bcf
HW		 59/*
60 * Used by test_cipher_speed()
61 */
6a17944c 62static unsigned int sec;
ebfd9bcf 63
af5d35b8 64static char *alg;
a873a5f1 65static u32 type;
7be380f7 66static u32 mask;
1da177e4 67static int mode;
8fcdc868 68static u32 num_mb = 8;
ba974adb 69static unsigned int klen;
f139cfa7 70static char *tvmem[TVMEMSIZE];
1da177e4 71
a7fc80bb 72static const int block_sizes[] = { 16, 64, 128, 256, 1024, 1420, 4096, 0 };
ad6d66bc 73static const int aead_sizes[] = { 16, 64, 256, 512, 1024, 1420, 4096, 8192, 0 };
427988d9
GBY		 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[0], assoc, aad_size);
122
123 if (rem)
124 np--;
125 for (k = 0; k < np; k++)
126 sg_set_buf(&sg[k + 1], xbuf[k], PAGE_SIZE);
127
128 if (rem)
129 sg_set_buf(&sg[k + 1], xbuf[k], rem);
130}
131
1425d2d1
VL		 132static inline int do_one_aead_op(struct aead_request *req, int ret)
133{
64671041 134 struct crypto_wait *wait = req->base.data;
1425d2d1 135
64671041 136 return crypto_wait_req(ret, wait);
1425d2d1
VL		 137}
138
427988d9
GBY		 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,
4e234eed 150 u32 num_mb, int *rc)
427988d9 151{
4e234eed 152 int i, err = 0;
427988d9
GBY		 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(data[i].req);
158 else
159 rc[i] = crypto_aead_decrypt(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(rc[i], &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)
53f52d7a
TC		 177{
178 unsigned long start, end;
179 int bcount;
4e234eed
KC		 180 int ret = 0;
181 int *rc;
182
183 rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
184 if (!rc)
185 return -ENOMEM;
53f52d7a 186
3e3dc25f 187 for (start = jiffies, end = start + secs * HZ, bcount = 0;
53f52d7a 188 time_before(jiffies, end); bcount++) {
4e234eed 189 ret = do_mult_aead_op(data, enc, num_mb, rc);
53f52d7a 190 if (ret)
4e234eed 191 goto out;
53f52d7a
TC		 192 }
193
303fd3e1
AB		 194 pr_cont("%d operations in %d seconds (%llu bytes)\n",
195 bcount * num_mb, secs, (u64)bcount * blen * num_mb);
4e234eed
KC		 196
197out:
198 kfree(rc);
199 return ret;
53f52d7a
TC		 200}
201
427988d9
GBY		 202static int test_mb_aead_cycles(struct test_mb_aead_data *data, int enc,
203 int blen, u32 num_mb)
53f52d7a
TC		 204{
205 unsigned long cycles = 0;
206 int ret = 0;
207 int i;
4e234eed
KC		 208 int *rc;
209
210 rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
211 if (!rc)
212 return -ENOMEM;
53f52d7a 213
53f52d7a
TC		 214 /* Warm-up run. */
215 for (i = 0; i < 4; i++) {
4e234eed 216 ret = do_mult_aead_op(data, enc, num_mb, rc);
53f52d7a
TC		 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();
4e234eed 226 ret = do_mult_aead_op(data, enc, num_mb, rc);
53f52d7a
TC		 227 end = get_cycles();
228
229 if (ret)
230 goto out;
231
232 cycles += end - start;
233 }
234
4e234eed
KC		 235 pr_cont("1 operation in %lu cycles (%d bytes)\n",
236 (cycles + 4) / (8 * num_mb), blen);
53f52d7a 237
4e234eed
KC		 238out:
239 kfree(rc);
53f52d7a
TC		 240 return ret;
241}
242
427988d9
GBY		 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;
ad6d66bc 251 const int *b_size;
427988d9
GBY		 252 const char *key;
253 const char *e;
254 void *assoc;
427988d9
GBY		 255 char *iv;
256 int ret;
53f52d7a 257
53f52d7a 258
427988d9
GBY		 259 if (aad_size >= PAGE_SIZE) {
260 pr_err("associate data length (%u) too big\n", aad_size);
261 return;
262 }
53f52d7a 263
427988d9
GBY		 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(algo, 0, 0);
278 if (IS_ERR(tfm)) {
279 pr_err("failed to load transform for %s: %ld\n",
280 algo, PTR_ERR(tfm));
281 goto out_free_data;
53f52d7a
TC		 282 }
283
427988d9 284 ret = crypto_aead_setauthsize(tfm, authsize);
7b3d5268
TZ		 285 if (ret) {
286 pr_err("alg: aead: Failed to setauthsize for %s: %d\n", algo,
287 ret);
288 goto out_free_tfm;
289 }
53f52d7a 290
427988d9
GBY		 291 for (i = 0; i < num_mb; ++i)
292 if (testmgr_alloc_buf(data[i].xbuf)) {
293 while (i--)
294 testmgr_free_buf(data[i].xbuf);
295 goto out_free_tfm;
296 }
53f52d7a 297
427988d9
GBY		 298 for (i = 0; i < num_mb; ++i)
299 if (testmgr_alloc_buf(data[i].axbuf)) {
300 while (i--)
301 testmgr_free_buf(data[i].axbuf);
302 goto out_free_xbuf;
303 }
304
305 for (i = 0; i < num_mb; ++i)
306 if (testmgr_alloc_buf(data[i].xoutbuf)) {
307 while (i--)
c6ba4f3e 308 testmgr_free_buf(data[i].xoutbuf);
427988d9
GBY		 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) {
7b3d5268 315 pr_err("alg: aead: Failed to allocate request for %s\n",
427988d9
GBY		 316 algo);
317 while (i--)
318 aead_request_free(data[i].req);
319 goto out_free_xoutbuf;
320 }
321 }
322
323 for (i = 0; i < num_mb; ++i) {
324 crypto_init_wait(&data[i].wait);
325 aead_request_set_callback(data[i].req,
326 CRYPTO_TFM_REQ_MAY_BACKLOG,
327 crypto_req_done, &data[i].wait);
328 }
329
3513828c 330 pr_info("testing speed of multibuffer %s (%s) %s\n", algo,
427988d9
GBY		 331 get_driver_name(crypto_aead, tfm), e);
332
333 i = 0;
334 do {
335 b_size = aead_sizes;
336 do {
ad6d66bc
AB		 337 int bs = round_up(*b_size, crypto_aead_blocksize(tfm));
338
339 if (bs + authsize > XBUFSIZE * PAGE_SIZE) {
38dbe2d1 340 pr_err("template (%u) too big for buffer (%lu)\n",
ad6d66bc 341 authsize + bs,
427988d9
GBY		 342 XBUFSIZE * PAGE_SIZE);
343 goto out;
344 }
345
346 pr_info("test %u (%d bit key, %d byte blocks): ", i,
ad6d66bc 347 *keysize * 8, bs);
427988d9
GBY		 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, ~0);
361
362 ret = crypto_aead_setkey(tfm, key, *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(cur->sg, cur->xbuf,
ad6d66bc 382 bs + (enc ? 0 : authsize),
427988d9
GBY		 383 assoc, aad_size);
384
385 sg_init_aead(cur->sgout, cur->xoutbuf,
ad6d66bc 386 bs + (enc ? authsize : 0),
427988d9
GBY		 387 assoc, aad_size);
388
389 aead_request_set_ad(cur->req, aad_size);
390
391 if (!enc) {
392
393 aead_request_set_crypt(cur->req,
394 cur->sgout,
395 cur->sg,
ad6d66bc 396 bs, iv);
427988d9
GBY		 397 ret = crypto_aead_encrypt(cur->req);
398 ret = do_one_aead_op(cur->req, ret);
399
400 if (ret) {
129a4dba 401 pr_err("calculating auth failed (%d)\n",
427988d9
GBY		 402 ret);
403 break;
404 }
405 }
406
407 aead_request_set_crypt(cur->req, cur->sg,
ad6d66bc 408 cur->sgout, bs +
427988d9
GBY		 409 (enc ? 0 : authsize),
410 iv);
411
412 }
413
2af63299 414 if (secs) {
ad6d66bc 415 ret = test_mb_aead_jiffies(data, enc, bs,
427988d9 416 secs, num_mb);
2af63299
HG		 417 cond_resched();
418 } else {
ad6d66bc 419 ret = test_mb_aead_cycles(data, enc, bs,
427988d9 420 num_mb);
2af63299 421 }
427988d9
GBY		 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(data[i].req);
436out_free_xoutbuf:
437 for (i = 0; i < num_mb; ++i)
438 testmgr_free_buf(data[i].xoutbuf);
439out_free_axbuf:
440 for (i = 0; i < num_mb; ++i)
441 testmgr_free_buf(data[i].axbuf);
442out_free_xbuf:
443 for (i = 0; i < num_mb; ++i)
444 testmgr_free_buf(data[i].xbuf);
445out_free_tfm:
446 crypto_free_aead(tfm);
447out_free_data:
448 kfree(data);
449out_free_iv:
450 kfree(iv);
53f52d7a
TC		 451}
452
427988d9
GBY		 453static int test_aead_jiffies(struct aead_request *req, int enc,
454 int blen, int secs)
53f52d7a 455{
427988d9
GBY		 456 unsigned long start, end;
457 int bcount;
458 int ret;
53f52d7a 459
427988d9
GBY		 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, crypto_aead_encrypt(req));
464 else
465 ret = do_one_aead_op(req, crypto_aead_decrypt(req));
466
467 if (ret)
468 return ret;
469 }
470
303fd3e1
AB		 471 pr_cont("%d operations in %d seconds (%llu bytes)\n",
472 bcount, secs, (u64)bcount * blen);
427988d9 473 return 0;
53f52d7a
TC		 474}
475
427988d9 476static int test_aead_cycles(struct aead_request *req, int enc, int blen)
53f52d7a 477{
427988d9
GBY		 478 unsigned long cycles = 0;
479 int ret = 0;
480 int i;
53f52d7a 481
427988d9
GBY		 482 /* Warm-up run. */
483 for (i = 0; i < 4; i++) {
484 if (enc)
485 ret = do_one_aead_op(req, crypto_aead_encrypt(req));
486 else
487 ret = do_one_aead_op(req, crypto_aead_decrypt(req));
488
489 if (ret)
490 goto out;
53f52d7a 491 }
c4768993 492
427988d9
GBY		 493 /* The real thing. */
494 for (i = 0; i < 8; i++) {
495 cycles_t start, end;
5601e014 496
427988d9
GBY		 497 start = get_cycles();
498 if (enc)
499 ret = do_one_aead_op(req, crypto_aead_encrypt(req));
500 else
501 ret = do_one_aead_op(req, crypto_aead_decrypt(req));
502 end = get_cycles();
5601e014 503
427988d9
GBY		 504 if (ret)
505 goto out;
c4768993 506
427988d9
GBY		 507 cycles += end - start;
508 }
509
510out:
511 if (ret == 0)
fdaeb224
AV		 512 pr_cont("1 operation in %lu cycles (%d bytes)\n",
513 (cycles + 4) / 8, blen);
427988d9
GBY		 514
515 return ret;
53f52d7a
TC		 516}
517
3e3dc25f 518static void test_aead_speed(const char *algo, int enc, unsigned int secs,
53f52d7a
TC		 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;
53f52d7a
TC		 529 struct scatterlist *sgout;
530 const char *e;
531 void *assoc;
96692a73 532 char *iv;
53f52d7a
TC		 533 char *xbuf[XBUFSIZE];
534 char *xoutbuf[XBUFSIZE];
535 char *axbuf[XBUFSIZE];
ad6d66bc 536 const int *b_size;
53f52d7a 537 unsigned int iv_len;
64671041 538 struct crypto_wait wait;
53f52d7a 539
96692a73
CS		 540 iv = kzalloc(MAX_IVLEN, GFP_KERNEL);
541 if (!iv)
542 return;
543
ac5f863f
CE		 544 if (aad_size >= PAGE_SIZE) {
545 pr_err("associate data length (%u) too big\n", aad_size);
96692a73 546 goto out_noxbuf;
ac5f863f
CE		 547 }
548
53f52d7a
TC		 549 if (enc == ENCRYPT)
550 e = "encryption";
551 else
552 e = "decryption";
553
554 if (testmgr_alloc_buf(xbuf))
555 goto out_noxbuf;
556 if (testmgr_alloc_buf(axbuf))
557 goto out_noaxbuf;
558 if (testmgr_alloc_buf(xoutbuf))
559 goto out_nooutbuf;
560
a3f2185a 561 sg = kmalloc(sizeof(*sg) * 9 * 2, GFP_KERNEL);
53f52d7a
TC		 562 if (!sg)
563 goto out_nosg;
a3f2185a 564 sgout = &sg[9];
53f52d7a 565
5e4b8c1f 566 tfm = crypto_alloc_aead(algo, 0, 0);
53f52d7a
TC		 567 if (IS_ERR(tfm)) {
568 pr_err("alg: aead: Failed to load transform for %s: %ld\n", algo,
569 PTR_ERR(tfm));
a2ea6ed6 570 goto out_notfm;
53f52d7a
TC		 571 }
572
7b3d5268
TZ		 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
64671041 580 crypto_init_wait(&wait);
3513828c 581 pr_info("testing speed of %s (%s) %s\n", algo,
837a99f5 582 get_driver_name(crypto_aead, tfm), e);
263a8df0 583
53f52d7a
TC		 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);
6af1f93e 588 goto out_noreq;
53f52d7a
TC		 589 }
590
1425d2d1 591 aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
64671041 592 crypto_req_done, &wait);
1425d2d1 593
53f52d7a
TC		 594 i = 0;
595 do {
596 b_size = aead_sizes;
597 do {
ad6d66bc
AB		 598 u32 bs = round_up(*b_size, crypto_aead_blocksize(tfm));
599
53f52d7a 600 assoc = axbuf[0];
ac5f863f 601 memset(assoc, 0xff, aad_size);
53f52d7a 602
ad6d66bc 603 if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) {
53f52d7a 604 pr_err("template (%u) too big for tvmem (%lu)\n",
ad6d66bc 605 *keysize + bs,
53f52d7a
TC		 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 }
7b3d5268 617
53f52d7a 618 ret = crypto_aead_setkey(tfm, key, *keysize);
7b3d5268
TZ		 619 if (ret) {
620 pr_err("setkey() failed flags=%x: %d\n",
621 crypto_aead_get_flags(tfm), ret);
622 goto out;
623 }
53f52d7a
TC		 624
625 iv_len = crypto_aead_ivsize(tfm);
626 if (iv_len)
96692a73 627 memset(iv, 0xff, iv_len);
53f52d7a
TC		 628
629 crypto_aead_clear_flags(tfm, ~0);
837a99f5
AV		 630 pr_info("test %u (%d bit key, %d byte blocks): ",
631 i, *keysize * 8, bs);
53f52d7a 632
53f52d7a
TC		 633 memset(tvmem[0], 0xff, PAGE_SIZE);
634
ad6d66bc 635 sg_init_aead(sg, xbuf, bs + (enc ? 0 : authsize),
5601e014 636 assoc, aad_size);
53f52d7a 637
31267270 638 sg_init_aead(sgout, xoutbuf,
ad6d66bc 639 bs + (enc ? authsize : 0), assoc,
5601e014 640 aad_size);
31267270 641
4431bd49
GBY		 642 aead_request_set_ad(req, 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, sgout, sg,
ad6d66bc 652 bs, iv);
4431bd49
GBY		 653 ret = do_one_aead_op(req,
654 crypto_aead_encrypt(req));
655
656 if (ret) {
129a4dba 657 pr_err("calculating auth failed (%d)\n",
4431bd49
GBY		 658 ret);
659 break;
660 }
661 }
662
7aacbfcb 663 aead_request_set_crypt(req, sg, sgout,
ad6d66bc 664 bs + (enc ? 0 : authsize),
7aacbfcb 665 iv);
53f52d7a 666
2af63299 667 if (secs) {
ad6d66bc 668 ret = test_aead_jiffies(req, enc, bs,
3e3dc25f 669 secs);
2af63299
HG		 670 cond_resched();
671 } else {
ad6d66bc 672 ret = test_aead_cycles(req, enc, bs);
2af63299 673 }
53f52d7a
TC		 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:
6af1f93e
CE		 686 aead_request_free(req);
687out_noreq:
53f52d7a 688 crypto_free_aead(tfm);
a2ea6ed6 689out_notfm:
53f52d7a
TC		 690 kfree(sg);
691out_nosg:
692 testmgr_free_buf(xoutbuf);
693out_nooutbuf:
694 testmgr_free_buf(axbuf);
695out_noaxbuf:
696 testmgr_free_buf(xbuf);
697out_noxbuf:
96692a73 698 kfree(iv);
53f52d7a 699}
d5dc3927 700
beb63da7
DM		 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 + i, tvmem[i], PAGE_SIZE);
708 memset(tvmem[i], 0xff, PAGE_SIZE);
709 }
710}
711
beb63da7
DM		 712static inline int do_one_ahash_op(struct ahash_request *req, int ret)
713{
64671041 714 struct crypto_wait *wait = req->base.data;
beb63da7 715
64671041 716 return crypto_wait_req(ret, wait);
beb63da7
DM		 717}
718
719static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
3e3dc25f 720 char *out, int secs)
beb63da7
DM		 721{
722 unsigned long start, end;
723 int bcount;
724 int ret;
725
3e3dc25f 726 for (start = jiffies, end = start + secs * HZ, bcount = 0;
beb63da7
DM		 727 time_before(jiffies, end); bcount++) {
728 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
729 if (ret)
730 return ret;
731 }
732
fdaeb224
AV		 733 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
734 bcount / secs, ((long)bcount * blen) / secs);
beb63da7
DM		 735
736 return 0;
737}
738
739static int test_ahash_jiffies(struct ahash_request *req, int blen,
3e3dc25f 740 int plen, char *out, int secs)
beb63da7
DM		 741{
742 unsigned long start, end;
743 int bcount, pcount;
744 int ret;
745
746 if (plen == blen)
3e3dc25f 747 return test_ahash_jiffies_digest(req, blen, out, secs);
beb63da7 748
3e3dc25f 749 for (start = jiffies, end = start + secs * HZ, bcount = 0;
beb63da7 750 time_before(jiffies, end); bcount++) {
43a9607d 751 ret = do_one_ahash_op(req, crypto_ahash_init(req));
beb63da7
DM		 752 if (ret)
753 return ret;
754 for (pcount = 0; pcount < blen; pcount += plen) {
755 ret = do_one_ahash_op(req, 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, crypto_ahash_final(req));
761 if (ret)
762 return ret;
763 }
764
765 pr_cont("%6u opers/sec, %9lu bytes/sec\n",
3e3dc25f 766 bcount / secs, ((long)bcount * blen) / secs);
beb63da7
DM		 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, 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, 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++) {
43a9607d 820 ret = do_one_ahash_op(req, crypto_ahash_init(req));
beb63da7
DM		 821 if (ret)
822 goto out;
823 for (pcount = 0; pcount < blen; pcount += plen) {
824 ret = do_one_ahash_op(req, crypto_ahash_update(req));
825 if (ret)
826 goto out;
827 }
828 ret = do_one_ahash_op(req, 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
43a9607d 839 ret = do_one_ahash_op(req, crypto_ahash_init(req));
beb63da7
DM		 840 if (ret)
841 goto out;
842 for (pcount = 0; pcount < blen; pcount += plen) {
843 ret = do_one_ahash_op(req, crypto_ahash_update(req));
844 if (ret)
845 goto out;
846 }
847 ret = do_one_ahash_op(req, 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
0660511c
HX		 866static void test_ahash_speed_common(const char *algo, unsigned int secs,
867 struct hash_speed *speed, unsigned mask)
beb63da7
DM		 868{
869 struct scatterlist sg[TVMEMSIZE];
64671041 870 struct crypto_wait wait;
beb63da7
DM		 871 struct ahash_request *req;
872 struct crypto_ahash *tfm;
f074f7b1 873 char *output;
beb63da7
DM		 874 int i, ret;
875
0660511c 876 tfm = crypto_alloc_ahash(algo, 0, mask);
beb63da7
DM		 877 if (IS_ERR(tfm)) {
878 pr_err("failed to load transform for %s: %ld\n",
879 algo, PTR_ERR(tfm));
880 return;
881 }
882
3513828c 883 pr_info("testing speed of async %s (%s)\n", algo,
837a99f5 884 get_driver_name(crypto_ahash, tfm));
263a8df0 885
f074f7b1
HG		 886 if (crypto_ahash_digestsize(tfm) > MAX_DIGEST_SIZE) {
887 pr_err("digestsize(%u) > %d\n", crypto_ahash_digestsize(tfm),
888 MAX_DIGEST_SIZE);
beb63da7
DM		 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
64671041 899 crypto_init_wait(&wait);
beb63da7 900 ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
64671041 901 crypto_req_done, &wait);
beb63da7 902
f074f7b1
HG		 903 output = kmalloc(MAX_DIGEST_SIZE, GFP_KERNEL);
904 if (!output)
905 goto out_nomem;
906
beb63da7
DM		 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
ba974adb
HX		 914 if (klen)
915 crypto_ahash_setkey(tfm, tvmem[0], klen);
331351f8 916
beb63da7
DM		 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, sg, output, speed[i].plen);
922
2af63299 923 if (secs) {
beb63da7 924 ret = test_ahash_jiffies(req, speed[i].blen,
3e3dc25f 925 speed[i].plen, output, secs);
2af63299
HG		 926 cond_resched();
927 } else {
beb63da7
DM		 928 ret = test_ahash_cycles(req, speed[i].blen,
929 speed[i].plen, output);
2af63299 930 }
beb63da7
DM		 931
932 if (ret) {
933 pr_err("hashing failed ret=%d\n", ret);
934 break;
935 }
936 }
937
f074f7b1
HG		 938 kfree(output);
939
940out_nomem:
beb63da7
DM		 941 ahash_request_free(req);
942
943out:
944 crypto_free_ahash(tfm);
945}
946
0660511c
HX		 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, 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
e161c593
GBY		 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,
4e234eed 967 u32 num_mb, int *rc)
e161c593 968{
4e234eed 969 int i, err = 0;
e161c593
GBY		 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(data[i].req);
975 else
976 rc[i] = crypto_skcipher_decrypt(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(rc[i], &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;
4e234eed
KC		 997 int ret = 0;
998 int *rc;
999
1000 rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
1001 if (!rc)
1002 return -ENOMEM;
e161c593
GBY		 1003
1004 for (start = jiffies, end = start + secs * HZ, bcount = 0;
1005 time_before(jiffies, end); bcount++) {
4e234eed 1006 ret = do_mult_acipher_op(data, enc, num_mb, rc);
e161c593 1007 if (ret)
4e234eed 1008 goto out;
e161c593
GBY		 1009 }
1010
303fd3e1
AB		 1011 pr_cont("%d operations in %d seconds (%llu bytes)\n",
1012 bcount * num_mb, secs, (u64)bcount * blen * num_mb);
4e234eed
KC		 1013
1014out:
1015 kfree(rc);
1016 return ret;
e161c593
GBY		 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;
4e234eed
KC		 1025 int *rc;
1026
1027 rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);
1028 if (!rc)
1029 return -ENOMEM;
e161c593
GBY		 1030
1031 /* Warm-up run. */
1032 for (i = 0; i < 4; i++) {
4e234eed 1033 ret = do_mult_acipher_op(data, enc, num_mb, rc);
e161c593
GBY		 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();
4e234eed 1043 ret = do_mult_acipher_op(data, enc, num_mb, rc);
e161c593
GBY		 1044 end = get_cycles();
1045
1046 if (ret)
1047 goto out;
1048
1049 cycles += end - start;
1050 }
1051
4e234eed
KC		 1052 pr_cont("1 operation in %lu cycles (%d bytes)\n",
1053 (cycles + 4) / (8 * num_mb), blen);
e161c593 1054
4e234eed
KC		 1055out:
1056 kfree(rc);
e161c593
GBY		 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;
ad6d66bc 1067 const int *b_size;
e161c593
GBY		 1068 const char *key;
1069 const char *e;
e161c593
GBY		 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(algo, 0, 0);
1083 if (IS_ERR(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(data[i].xbuf)) {
1091 while (i--)
1092 testmgr_free_buf(data[i].xbuf);
1093 goto out_free_tfm;
1094 }
1095
e161c593
GBY		 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(data[i].req);
1103 goto out_free_xbuf;
1104 }
1105 }
1106
1107 for (i = 0; i < num_mb; ++i) {
1108 skcipher_request_set_callback(data[i].req,
1109 CRYPTO_TFM_REQ_MAY_BACKLOG,
1110 crypto_req_done, &data[i].wait);
1111 crypto_init_wait(&data[i].wait);
1112 }
1113
3513828c 1114 pr_info("testing speed of multibuffer %s (%s) %s\n", algo,
e161c593
GBY		 1115 get_driver_name(crypto_skcipher, tfm), e);
1116
1117 i = 0;
1118 do {
1119 b_size = block_sizes;
1120 do {
ad6d66bc
AB		 1121 u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm));
1122
1123 if (bs > XBUFSIZE * PAGE_SIZE) {
38dbe2d1 1124 pr_err("template (%u) too big for buffer (%lu)\n",
3ae88f67 1125 bs, XBUFSIZE * PAGE_SIZE);
e161c593
GBY		 1126 goto out;
1127 }
1128
1129 pr_info("test %u (%d bit key, %d byte blocks): ", i,
ad6d66bc 1130 *keysize * 8, bs);
e161c593
GBY		 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, ~0);
1144
1145 ret = crypto_skcipher_setkey(tfm, key, *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];
ad6d66bc 1160 unsigned int k = bs;
e161c593
GBY		 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(cur->sg + p, 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(cur->sg + p, cur->xbuf[p], k);
1175 memset(cur->xbuf[p], 0xff, k);
1176
1177 skcipher_request_set_crypt(cur->req, cur->sg,
3ae88f67 1178 cur->sg, bs, iv);
e161c593
GBY		 1179 }
1180
2af63299 1181 if (secs) {
e161c593 1182 ret = test_mb_acipher_jiffies(data, enc,
ad6d66bc 1183 bs, secs,
e161c593 1184 num_mb);
2af63299
HG		 1185 cond_resched();
1186 } else {
e161c593 1187 ret = test_mb_acipher_cycles(data, enc,
ad6d66bc 1188 bs, num_mb);
2af63299 1189 }
e161c593
GBY		 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(data[i].req);
1205out_free_xbuf:
1206 for (i = 0; i < num_mb; ++i)
1207 testmgr_free_buf(data[i].xbuf);
1208out_free_tfm:
1209 crypto_free_skcipher(tfm);
1210out_free_data:
1211 kfree(data);
1212}
1213
7166e589 1214static inline int do_one_acipher_op(struct skcipher_request *req, int ret)
3f3baf35 1215{
64671041 1216 struct crypto_wait *wait = req->base.data;
3f3baf35 1217
64671041 1218 return crypto_wait_req(ret, wait);
3f3baf35
JK		 1219}
1220
7166e589 1221static int test_acipher_jiffies(struct skcipher_request *req, int enc,
3e3dc25f 1222 int blen, int secs)
3f3baf35
JK		 1223{
1224 unsigned long start, end;
1225 int bcount;
1226 int ret;
1227
3e3dc25f 1228 for (start = jiffies, end = start + secs * HZ, bcount = 0;
3f3baf35
JK		 1229 time_before(jiffies, end); bcount++) {
1230 if (enc)
1231 ret = do_one_acipher_op(req,
7166e589 1232 crypto_skcipher_encrypt(req));
3f3baf35
JK		 1233 else
1234 ret = do_one_acipher_op(req,
7166e589 1235 crypto_skcipher_decrypt(req));
3f3baf35
JK		 1236
1237 if (ret)
1238 return ret;
1239 }
1240
303fd3e1
AB		 1241 pr_cont("%d operations in %d seconds (%llu bytes)\n",
1242 bcount, secs, (u64)bcount * blen);
3f3baf35
JK		 1243 return 0;
1244}
1245
7166e589 1246static int test_acipher_cycles(struct skcipher_request *req, int enc,
3f3baf35
JK		 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,
7166e589 1257 crypto_skcipher_encrypt(req));
3f3baf35
JK		 1258 else
1259 ret = do_one_acipher_op(req,
7166e589 1260 crypto_skcipher_decrypt(req));
3f3baf35
JK		 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,
7166e589 1273 crypto_skcipher_encrypt(req));
3f3baf35
JK		 1274 else
1275 ret = do_one_acipher_op(req,
7166e589 1276 crypto_skcipher_decrypt(req));
3f3baf35
JK		 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
7166e589
HX		 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)
3f3baf35 1296{
de197533 1297 unsigned int ret, i, j, k, iv_len;
64671041 1298 struct crypto_wait wait;
3f3baf35
JK		 1299 const char *key;
1300 char iv[128];
7166e589
HX		 1301 struct skcipher_request *req;
1302 struct crypto_skcipher *tfm;
ad6d66bc 1303 const int *b_size;
3f3baf35 1304 const char *e;
3f3baf35
JK		 1305
1306 if (enc == ENCRYPT)
1307 e = "encryption";
1308 else
1309 e = "decryption";
1310
64671041 1311 crypto_init_wait(&wait);
3f3baf35 1312
7166e589 1313 tfm = crypto_alloc_skcipher(algo, 0, async ? 0 : CRYPTO_ALG_ASYNC);
3f3baf35
JK		 1314
1315 if (IS_ERR(tfm)) {
1316 pr_err("failed to load transform for %s: %ld\n", algo,
1317 PTR_ERR(tfm));
1318 return;
1319 }
1320
3513828c 1321 pr_info("testing speed of %s %s (%s) %s\n", async ? "async" : "sync",
8e3b7fd7 1322 algo, get_driver_name(crypto_skcipher, tfm), e);
263a8df0 1323
7166e589 1324 req = skcipher_request_alloc(tfm, GFP_KERNEL);
3f3baf35 1325 if (!req) {
a2ef5630 1326 pr_err("skcipher: Failed to allocate request for %s\n", algo);
3f3baf35
JK		 1327 goto out;
1328 }
1329
7166e589 1330 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
64671041 1331 crypto_req_done, &wait);
3f3baf35
JK		 1332
1333 i = 0;
1334 do {
1335 b_size = block_sizes;
1336
1337 do {
ad6d66bc 1338 u32 bs = round_up(*b_size, crypto_skcipher_blocksize(tfm));
3f3baf35
JK		 1339 struct scatterlist sg[TVMEMSIZE];
1340
ad6d66bc 1341 if ((*keysize + bs) > TVMEMSIZE * PAGE_SIZE) {
3f3baf35 1342 pr_err("template (%u) too big for "
ad6d66bc 1343 "tvmem (%lu)\n", *keysize + bs,
3f3baf35
JK		 1344 TVMEMSIZE * PAGE_SIZE);
1345 goto out_free_req;
1346 }
1347
1348 pr_info("test %u (%d bit key, %d byte blocks): ", i,
ad6d66bc 1349 *keysize * 8, bs);
3f3baf35
JK		 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
7166e589 1362 crypto_skcipher_clear_flags(tfm, ~0);
3f3baf35 1363
7166e589 1364 ret = crypto_skcipher_setkey(tfm, key, *keysize);
3f3baf35
JK		 1365 if (ret) {
1366 pr_err("setkey() failed flags=%x\n",
7166e589 1367 crypto_skcipher_get_flags(tfm));
3f3baf35
JK		 1368 goto out_free_req;
1369 }
1370
ad6d66bc 1371 k = *keysize + bs;
007ee8de
HG		 1372 sg_init_table(sg, DIV_ROUND_UP(k, PAGE_SIZE));
1373
de197533
NR		 1374 if (k > PAGE_SIZE) {
1375 sg_set_buf(sg, tvmem[0] + *keysize,
3f3baf35 1376 PAGE_SIZE - *keysize);
de197533
NR		 1377 k -= PAGE_SIZE;
1378 j = 1;
1379 while (k > PAGE_SIZE) {
1380 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
1381 memset(tvmem[j], 0xff, PAGE_SIZE);
1382 j++;
1383 k -= PAGE_SIZE;
1384 }
1385 sg_set_buf(sg + j, tvmem[j], k);
1386 memset(tvmem[j], 0xff, k);
1387 } else {
ad6d66bc 1388 sg_set_buf(sg, tvmem[0] + *keysize, bs);
3f3baf35
JK		 1389 }
1390
7166e589 1391 iv_len = crypto_skcipher_ivsize(tfm);
3f3baf35
JK		 1392 if (iv_len)
1393 memset(&iv, 0xff, iv_len);
1394
ad6d66bc 1395 skcipher_request_set_crypt(req, sg, sg, bs, iv);
3f3baf35 1396
2af63299 1397 if (secs) {
3f3baf35 1398 ret = test_acipher_jiffies(req, enc,
ad6d66bc 1399 bs, secs);
2af63299
HG		 1400 cond_resched();
1401 } else {
3f3baf35 1402 ret = test_acipher_cycles(req, enc,
ad6d66bc 1403 bs);
2af63299 1404 }
3f3baf35
JK		 1405
1406 if (ret) {
1407 pr_err("%s() failed flags=%x\n", e,
7166e589 1408 crypto_skcipher_get_flags(tfm));
3f3baf35
JK		 1409 break;
1410 }
1411 b_size++;
1412 i++;
1413 } while (*b_size);
1414 keysize++;
1415 } while (*keysize);
1416
1417out_free_req:
7166e589 1418 skcipher_request_free(req);
3f3baf35 1419out:
7166e589
HX		 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 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 false);
3f3baf35
JK		 1437}
1438
01b32324
HX		 1439static inline int tcrypt_test(const char *alg)
1440{
4e033a6b
JW		 1441 int ret;
1442
76512f2d
RV		 1443 pr_debug("testing %s\n", alg);
1444
4e033a6b 1445 ret = alg_test(alg, alg, 0, 0);
d6097b8d
NS		 1446 /* non-fips algs return -EINVAL or -ECANCELED in fips mode */
1447 if (fips_enabled && (ret == -EINVAL || ret == -ECANCELED))
4e033a6b
JW		 1448 ret = 0;
1449 return ret;
01b32324
HX		 1450}
1451
4e234eed 1452static int do_test(const char *alg, u32 type, u32 mask, int m, u32 num_mb)
01b32324
HX		 1453{
1454 int i;
4e033a6b 1455 int ret = 0;
01b32324
HX		 1456
1457 switch (m) {
1da177e4 1458 case 0:
8606813a
HX		 1459 if (alg) {
1460 if (!crypto_has_alg(alg, type,
1461 mask ?: CRYPTO_ALG_TYPE_MASK))
1462 ret = -ENOENT;
1463 break;
1464 }
1465
01b32324 1466 for (i = 1; i < 200; i++)
65c92cbb 1467 ret = min(ret, do_test(NULL, 0, 0, i, num_mb));
1da177e4
LT		 1468 break;
1469
1470 case 1:
65c92cbb 1471 ret = min(ret, tcrypt_test("md5"));
1da177e4
LT		 1472 break;
1473
1474 case 2:
65c92cbb 1475 ret = min(ret, tcrypt_test("sha1"));
1da177e4
LT		 1476 break;
1477
1478 case 3:
65c92cbb
RE		 1479 ret = min(ret, tcrypt_test("ecb(des)"));
1480 ret = min(ret, tcrypt_test("cbc(des)"));
1481 ret = min(ret, tcrypt_test("ctr(des)"));
1da177e4
LT		 1482 break;
1483
1484 case 4:
65c92cbb
RE		 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)"));
1da177e4
LT		 1488 break;
1489
1490 case 5:
65c92cbb 1491 ret = min(ret, tcrypt_test("md4"));
1da177e4 1492 break;
ef2736fc 1493
1da177e4 1494 case 6:
65c92cbb 1495 ret = min(ret, tcrypt_test("sha256"));
1da177e4 1496 break;
ef2736fc 1497
1da177e4 1498 case 7:
65c92cbb
RE		 1499 ret = min(ret, tcrypt_test("ecb(blowfish)"));
1500 ret = min(ret, tcrypt_test("cbc(blowfish)"));
1501 ret = min(ret, tcrypt_test("ctr(blowfish)"));
1da177e4
LT		 1502 break;
1503
1504 case 8:
65c92cbb
RE		 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)"));
1da177e4 1510 break;
ef2736fc 1511
1da177e4 1512 case 9:
65c92cbb
RE		 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)"));
1da177e4
LT		 1518 break;
1519
1520 case 10:
65c92cbb
RE		 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("ofb(aes)"));
1528 ret = min(ret, tcrypt_test("cfb(aes)"));
1529 ret = min(ret, tcrypt_test("xctr(aes)"));
1da177e4
LT		 1530 break;
1531
1532 case 11:
65c92cbb 1533 ret = min(ret, tcrypt_test("sha384"));
1da177e4 1534 break;
ef2736fc 1535
1da177e4 1536 case 12:
65c92cbb 1537 ret = min(ret, tcrypt_test("sha512"));
1da177e4
LT		 1538 break;
1539
1540 case 13:
65c92cbb 1541 ret = min(ret, tcrypt_test("deflate"));
1da177e4
LT		 1542 break;
1543
1544 case 14:
65c92cbb
RE		 1545 ret = min(ret, tcrypt_test("ecb(cast5)"));
1546 ret = min(ret, tcrypt_test("cbc(cast5)"));
1547 ret = min(ret, tcrypt_test("ctr(cast5)"));
1da177e4
LT		 1548 break;
1549
1550 case 15:
65c92cbb
RE		 1551 ret = min(ret, tcrypt_test("ecb(cast6)"));
1552 ret = min(ret, tcrypt_test("cbc(cast6)"));
1553 ret = min(ret, tcrypt_test("ctr(cast6)"));
1554 ret = min(ret, tcrypt_test("lrw(cast6)"));
1555 ret = min(ret, tcrypt_test("xts(cast6)"));
1da177e4
LT		 1556 break;
1557
1558 case 16:
65c92cbb 1559 ret = min(ret, tcrypt_test("ecb(arc4)"));
1da177e4
LT		 1560 break;
1561
1562 case 17:
65c92cbb 1563 ret = min(ret, tcrypt_test("michael_mic"));
1da177e4
LT		 1564 break;
1565
1566 case 18:
65c92cbb 1567 ret = min(ret, tcrypt_test("crc32c"));
1da177e4
LT		 1568 break;
1569
1570 case 19:
65c92cbb 1571 ret = min(ret, tcrypt_test("ecb(tea)"));
1da177e4
LT		 1572 break;
1573
1574 case 20:
65c92cbb 1575 ret = min(ret, tcrypt_test("ecb(xtea)"));
1da177e4
LT		 1576 break;
1577
1578 case 21:
65c92cbb 1579 ret = min(ret, tcrypt_test("ecb(khazad)"));
1da177e4
LT		 1580 break;
1581
1582 case 22:
65c92cbb 1583 ret = min(ret, tcrypt_test("wp512"));
1da177e4
LT		 1584 break;
1585
1586 case 23:
65c92cbb 1587 ret = min(ret, tcrypt_test("wp384"));
1da177e4
LT		 1588 break;
1589
1590 case 24:
65c92cbb 1591 ret = min(ret, tcrypt_test("wp256"));
1da177e4
LT		 1592 break;
1593
1da177e4 1594 case 26:
65c92cbb
RE		 1595 ret = min(ret, tcrypt_test("ecb(anubis)"));
1596 ret = min(ret, tcrypt_test("cbc(anubis)"));
1da177e4
LT		 1597 break;
1598
fb4f10ed 1599 case 30:
65c92cbb 1600 ret = min(ret, tcrypt_test("ecb(xeta)"));
fb4f10ed 1601 break;
1da177e4 1602
90831639 1603 case 31:
65c92cbb 1604 ret = min(ret, tcrypt_test("pcbc(fcrypt)"));
90831639
DH		 1605 break;
1606
02ab5a70 1607 case 32:
65c92cbb
RE		 1608 ret = min(ret, tcrypt_test("ecb(camellia)"));
1609 ret = min(ret, tcrypt_test("cbc(camellia)"));
1610 ret = min(ret, tcrypt_test("ctr(camellia)"));
1611 ret = min(ret, tcrypt_test("lrw(camellia)"));
1612 ret = min(ret, tcrypt_test("xts(camellia)"));
02ab5a70 1613 break;
93b5e86a 1614
cd12fb90 1615 case 33:
65c92cbb 1616 ret = min(ret, tcrypt_test("sha224"));
cd12fb90 1617 break;
02ab5a70 1618
8df213d9 1619 case 35:
65c92cbb 1620 ret = min(ret, tcrypt_test("gcm(aes)"));
8df213d9
HX		 1621 break;
1622
0b77abb3 1623 case 36:
65c92cbb 1624 ret = min(ret, tcrypt_test("lzo"));
0b77abb3
ZS		 1625 break;
1626
93cc74e0 1627 case 37:
65c92cbb 1628 ret = min(ret, tcrypt_test("ccm(aes)"));
93cc74e0
JL		 1629 break;
1630
76cb9521 1631 case 38:
65c92cbb 1632 ret = min(ret, tcrypt_test("cts(cbc(aes))"));
76cb9521
KC		 1633 break;
1634
aa22cd7f 1635 case 39:
65c92cbb 1636 ret = min(ret, tcrypt_test("xxhash64"));
aa22cd7f
AB		 1637 break;
1638
fd4adf1a 1639 case 40:
65c92cbb 1640 ret = min(ret, tcrypt_test("rmd160"));
fd4adf1a
AKR		 1641 break;
1642
aa22cd7f 1643 case 42:
65c92cbb 1644 ret = min(ret, tcrypt_test("blake2b-512"));
aa22cd7f
AB		 1645 break;
1646
01b32324 1647 case 43:
65c92cbb 1648 ret = min(ret, tcrypt_test("ecb(seed)"));
2998db37
AKR		 1649 break;
1650
5d667322 1651 case 45:
65c92cbb 1652 ret = min(ret, tcrypt_test("rfc4309(ccm(aes))"));
5d667322
JW		 1653 break;
1654
54216bbd 1655 case 46:
65c92cbb 1656 ret = min(ret, tcrypt_test("ghash"));
54216bbd
JK		 1657 break;
1658
68411521 1659 case 47:
65c92cbb 1660 ret = min(ret, tcrypt_test("crct10dif"));
68411521
HX		 1661 break;
1662
79cc6ab8 1663 case 48:
65c92cbb 1664 ret = min(ret, tcrypt_test("sha3-224"));
79cc6ab8 1665 break;
1666
1667 case 49:
65c92cbb 1668 ret = min(ret, tcrypt_test("sha3-256"));
79cc6ab8 1669 break;
1670
1671 case 50:
65c92cbb 1672 ret = min(ret, tcrypt_test("sha3-384"));
79cc6ab8 1673 break;
1674
1675 case 51:
65c92cbb 1676 ret = min(ret, tcrypt_test("sha3-512"));
79cc6ab8 1677 break;
1678
b7e27530 1679 case 52:
65c92cbb 1680 ret = min(ret, tcrypt_test("sm3"));
b7e27530
GBY		 1681 break;
1682
25a0b9d4 1683 case 53:
65c92cbb 1684 ret = min(ret, tcrypt_test("streebog256"));
25a0b9d4
VC		 1685 break;
1686
1687 case 54:
65c92cbb 1688 ret = min(ret, tcrypt_test("streebog512"));
25a0b9d4
VC		 1689 break;
1690
357a753f 1691 case 55:
65c92cbb 1692 ret = min(ret, tcrypt_test("gcm(sm4)"));
357a753f
TZ		 1693 break;
1694
1695 case 56:
65c92cbb 1696 ret = min(ret, tcrypt_test("ccm(sm4)"));
357a753f
TZ		 1697 break;
1698
f3c923a0 1699 case 57:
65c92cbb 1700 ret = min(ret, tcrypt_test("polyval"));
f3c923a0
NH		 1701 break;
1702
01ce31de 1703 case 58:
65c92cbb 1704 ret = min(ret, tcrypt_test("gcm(aria)"));
01ce31de
TY		 1705 break;
1706
3c383637
TZ		 1707 case 59:
1708 ret = min(ret, tcrypt_test("cts(cbc(sm4))"));
1709 break;
1710
1da177e4 1711 case 100:
65c92cbb 1712 ret = min(ret, tcrypt_test("hmac(md5)"));
1da177e4 1713 break;
ef2736fc 1714
1da177e4 1715 case 101:
65c92cbb 1716 ret = min(ret, tcrypt_test("hmac(sha1)"));
1da177e4 1717 break;
ef2736fc 1718
1da177e4 1719 case 102:
65c92cbb 1720 ret = min(ret, tcrypt_test("hmac(sha256)"));
1da177e4
LT		 1721 break;
1722
a28091ae 1723 case 103:
65c92cbb 1724 ret = min(ret, tcrypt_test("hmac(sha384)"));
a28091ae
AD		 1725 break;
1726
1727 case 104:
65c92cbb 1728 ret = min(ret, tcrypt_test("hmac(sha512)"));
a28091ae 1729 break;
38ed9ab2 1730
cd12fb90 1731 case 105:
65c92cbb 1732 ret = min(ret, tcrypt_test("hmac(sha224)"));
cd12fb90 1733 break;
1da177e4 1734
38ed9ab2 1735 case 106:
65c92cbb 1736 ret = min(ret, tcrypt_test("xcbc(aes)"));
38ed9ab2
HX		 1737 break;
1738
fd4adf1a 1739 case 108:
65c92cbb 1740 ret = min(ret, tcrypt_test("hmac(rmd160)"));
fd4adf1a
AKR		 1741 break;
1742
f1939f7c 1743 case 109:
65c92cbb 1744 ret = min(ret, tcrypt_test("vmac64(aes)"));
f1939f7c 1745 break;
93b5e86a 1746
98eca72f 1747 case 111:
65c92cbb 1748 ret = min(ret, tcrypt_test("hmac(sha3-224)"));
98eca72f 1749 break;
1750
1751 case 112:
65c92cbb 1752 ret = min(ret, tcrypt_test("hmac(sha3-256)"));
98eca72f 1753 break;
1754
1755 case 113:
65c92cbb 1756 ret = min(ret, tcrypt_test("hmac(sha3-384)"));
98eca72f 1757 break;
1758
1759 case 114:
65c92cbb 1760 ret = min(ret, tcrypt_test("hmac(sha3-512)"));
98eca72f 1761 break;
1762
25a0b9d4 1763 case 115:
65c92cbb 1764 ret = min(ret, tcrypt_test("hmac(streebog256)"));
25a0b9d4
VC		 1765 break;
1766
1767 case 116:
65c92cbb 1768 ret = min(ret, tcrypt_test("hmac(streebog512)"));
25a0b9d4
VC		 1769 break;
1770
e08ca2da 1771 case 150:
65c92cbb 1772 ret = min(ret, tcrypt_test("ansi_cprng"));
e08ca2da
JW		 1773 break;
1774
69435b94 1775 case 151:
65c92cbb 1776 ret = min(ret, tcrypt_test("rfc4106(gcm(aes))"));
69435b94
AH		 1777 break;
1778
e9b7441a 1779 case 152:
65c92cbb 1780 ret = min(ret, tcrypt_test("rfc4543(gcm(aes))"));
e9b7441a
JK		 1781 break;
1782
93b5e86a 1783 case 153:
65c92cbb 1784 ret = min(ret, tcrypt_test("cmac(aes)"));
93b5e86a
JK		 1785 break;
1786
1787 case 154:
65c92cbb 1788 ret = min(ret, tcrypt_test("cmac(des3_ede)"));
93b5e86a
JK		 1789 break;
1790
bbf9c893 1791 case 155:
65c92cbb 1792 ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(aes))"));
bbf9c893
HG		 1793 break;
1794
bca4feb0 1795 case 156:
65c92cbb 1796 ret = min(ret, tcrypt_test("authenc(hmac(md5),ecb(cipher_null))"));
bca4feb0
HG		 1797 break;
1798
1799 case 157:
65c92cbb 1800 ret = min(ret, tcrypt_test("authenc(hmac(sha1),ecb(cipher_null))"));
bca4feb0 1801 break;
357a753f
TZ		 1802
1803 case 158:
65c92cbb 1804 ret = min(ret, tcrypt_test("cbcmac(sm4)"));
357a753f
TZ		 1805 break;
1806
1807 case 159:
65c92cbb 1808 ret = min(ret, tcrypt_test("cmac(sm4)"));
357a753f
TZ		 1809 break;
1810
3c383637
TZ		 1811 case 160:
1812 ret = min(ret, tcrypt_test("xcbc(sm4)"));
1813 break;
1814
5208ed2c 1815 case 181:
65c92cbb 1816 ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(des))"));
5208ed2c
NL		 1817 break;
1818 case 182:
65c92cbb 1819 ret = min(ret, tcrypt_test("authenc(hmac(sha1),cbc(des3_ede))"));
5208ed2c
NL		 1820 break;
1821 case 183:
65c92cbb 1822 ret = min(ret, tcrypt_test("authenc(hmac(sha224),cbc(des))"));
5208ed2c
NL		 1823 break;
1824 case 184:
65c92cbb 1825 ret = min(ret, tcrypt_test("authenc(hmac(sha224),cbc(des3_ede))"));
5208ed2c
NL		 1826 break;
1827 case 185:
65c92cbb 1828 ret = min(ret, tcrypt_test("authenc(hmac(sha256),cbc(des))"));
5208ed2c
NL		 1829 break;
1830 case 186:
65c92cbb 1831 ret = min(ret, tcrypt_test("authenc(hmac(sha256),cbc(des3_ede))"));
5208ed2c
NL		 1832 break;
1833 case 187:
65c92cbb 1834 ret = min(ret, tcrypt_test("authenc(hmac(sha384),cbc(des))"));
5208ed2c
NL		 1835 break;
1836 case 188:
65c92cbb 1837 ret = min(ret, tcrypt_test("authenc(hmac(sha384),cbc(des3_ede))"));
5208ed2c
NL		 1838 break;
1839 case 189:
65c92cbb 1840 ret = min(ret, tcrypt_test("authenc(hmac(sha512),cbc(des))"));
5208ed2c
NL		 1841 break;
1842 case 190:
65c92cbb 1843 ret = min(ret, tcrypt_test("authenc(hmac(sha512),cbc(des3_ede))"));
5208ed2c 1844 break;
cd83a8a7 1845 case 191:
65c92cbb
RE		 1846 ret = min(ret, tcrypt_test("ecb(sm4)"));
1847 ret = min(ret, tcrypt_test("cbc(sm4)"));
1848 ret = min(ret, tcrypt_test("cfb(sm4)"));
1849 ret = min(ret, tcrypt_test("ctr(sm4)"));
3c383637 1850 ret = min(ret, tcrypt_test("xts(sm4)"));
cd83a8a7 1851 break;
01ce31de 1852 case 192:
65c92cbb
RE		 1853 ret = min(ret, tcrypt_test("ecb(aria)"));
1854 ret = min(ret, tcrypt_test("cbc(aria)"));
1855 ret = min(ret, tcrypt_test("cfb(aria)"));
1856 ret = min(ret, tcrypt_test("ctr(aria)"));
01ce31de 1857 break;
ebfd9bcf 1858 case 200:
cba83564 1859 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1860 speed_template_16_24_32);
cba83564 1861 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
477035c2 1862 speed_template_16_24_32);
cba83564 1863 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1864 speed_template_16_24_32);
cba83564 1865 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
477035c2 1866 speed_template_16_24_32);
f3d1044c 1867 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
477035c2 1868 speed_template_32_40_48);
f3d1044c 1869 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
477035c2 1870 speed_template_32_40_48);
f19f5111 1871 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
b66ad0b7 1872 speed_template_32_64);
f19f5111 1873 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
b66ad0b7 1874 speed_template_32_64);
1503a24f
HX		 1875 test_cipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
1876 speed_template_16_24_32);
1877 test_cipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
1878 speed_template_16_24_32);
9996e342
JG		 1879 test_cipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
1880 speed_template_16_24_32);
1881 test_cipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
1882 speed_template_16_24_32);
7da66670
DES		 1883 test_cipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
1884 speed_template_16_24_32);
1885 test_cipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
1886 speed_template_16_24_32);
ebfd9bcf
HW		 1887 break;
1888
1889 case 201:
cba83564 1890 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
da7f033d 1891 des3_speed_template, DES3_SPEED_VECTORS,
477035c2 1892 speed_template_24);
cba83564 1893 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
da7f033d 1894 des3_speed_template, DES3_SPEED_VECTORS,
477035c2 1895 speed_template_24);
cba83564 1896 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
da7f033d 1897 des3_speed_template, DES3_SPEED_VECTORS,
477035c2 1898 speed_template_24);
cba83564 1899 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
da7f033d 1900 des3_speed_template, DES3_SPEED_VECTORS,
477035c2 1901 speed_template_24);
87131507
JK		 1902 test_cipher_speed("ctr(des3_ede)", ENCRYPT, sec,
1903 des3_speed_template, DES3_SPEED_VECTORS,
1904 speed_template_24);
1905 test_cipher_speed("ctr(des3_ede)", DECRYPT, sec,
1906 des3_speed_template, DES3_SPEED_VECTORS,
1907 speed_template_24);
ebfd9bcf
HW		 1908 break;
1909
1910 case 202:
cba83564 1911 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
477035c2 1912 speed_template_16_24_32);
cba83564 1913 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
477035c2 1914 speed_template_16_24_32);
cba83564 1915 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
477035c2 1916 speed_template_16_24_32);
cba83564 1917 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
477035c2 1918 speed_template_16_24_32);
ee5002a5
JK		 1919 test_cipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
1920 speed_template_16_24_32);
1921 test_cipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
1922 speed_template_16_24_32);
bee3a90e
JK		 1923 test_cipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
1924 speed_template_32_40_48);
1925 test_cipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
1926 speed_template_32_40_48);
131f7541
JK		 1927 test_cipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
1928 speed_template_32_48_64);
1929 test_cipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
1930 speed_template_32_48_64);
ebfd9bcf
HW		 1931 break;
1932
1933 case 203:
cba83564 1934 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
477035c2 1935 speed_template_8_32);
cba83564 1936 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
477035c2 1937 speed_template_8_32);
cba83564 1938 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
477035c2 1939 speed_template_8_32);
cba83564 1940 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
477035c2 1941 speed_template_8_32);
7d47b86c
JK		 1942 test_cipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
1943 speed_template_8_32);
1944 test_cipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
1945 speed_template_8_32);
ebfd9bcf
HW		 1946 break;
1947
1948 case 204:
cba83564 1949 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
477035c2 1950 speed_template_8);
cba83564 1951 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
477035c2 1952 speed_template_8);
cba83564 1953 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
477035c2 1954 speed_template_8);
cba83564 1955 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
477035c2 1956 speed_template_8);
ebfd9bcf
HW		 1957 break;
1958
02ab5a70
NT		 1959 case 205:
1960 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
477035c2 1961 speed_template_16_24_32);
02ab5a70 1962 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
477035c2 1963 speed_template_16_24_32);
02ab5a70 1964 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
477035c2 1965 speed_template_16_24_32);
02ab5a70 1966 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
477035c2 1967 speed_template_16_24_32);
4de59337
JK		 1968 test_cipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
1969 speed_template_16_24_32);
1970 test_cipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
1971 speed_template_16_24_32);
1972 test_cipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
1973 speed_template_32_40_48);
1974 test_cipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
1975 speed_template_32_40_48);
1976 test_cipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
1977 speed_template_32_48_64);
1978 test_cipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
1979 speed_template_32_48_64);
02ab5a70
NT		 1980 break;
1981
7fb7fe44
JK		 1982 case 207:
1983 test_cipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
1984 speed_template_16_32);
1985 test_cipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
1986 speed_template_16_32);
1987 test_cipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
1988 speed_template_16_32);
1989 test_cipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
1990 speed_template_16_32);
1991 test_cipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
1992 speed_template_16_32);
1993 test_cipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
1994 speed_template_16_32);
87aae4bf
JK		 1995 test_cipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
1996 speed_template_32_48);
1997 test_cipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
1998 speed_template_32_48);
5209c07a
JK		 1999 test_cipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2000 speed_template_32_64);
2001 test_cipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2002 speed_template_32_64);
7fb7fe44
JK		 2003 break;
2004
31b4cd29
JK		 2005 case 208:
2006 test_cipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2007 speed_template_8);
2008 break;
2009
a2c58260
JG		 2010 case 209:
2011 test_cipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2012 speed_template_8_16);
2013 test_cipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2014 speed_template_8_16);
2015 test_cipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2016 speed_template_8_16);
2017 test_cipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2018 speed_template_8_16);
2019 test_cipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2020 speed_template_8_16);
2021 test_cipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2022 speed_template_8_16);
2023 break;
2024
9b8b0405
JG		 2025 case 210:
2026 test_cipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2027 speed_template_16_32);
2028 test_cipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2029 speed_template_16_32);
2030 test_cipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2031 speed_template_16_32);
2032 test_cipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2033 speed_template_16_32);
2034 test_cipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2035 speed_template_16_32);
2036 test_cipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2037 speed_template_16_32);
2038 test_cipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2039 speed_template_32_48);
2040 test_cipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2041 speed_template_32_48);
2042 test_cipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2043 speed_template_32_64);
2044 test_cipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2045 speed_template_32_64);
2046 break;
2047
53f52d7a
TC		 2048 case 211:
2049 test_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec,
425359ae 2050 NULL, 0, 16, 16, aead_speed_template_20_28_36);
1425d2d1 2051 test_aead_speed("gcm(aes)", ENCRYPT, sec,
f18611da 2052 NULL, 0, 16, 8, speed_template_16_24_32);
4431bd49 2053 test_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec,
425359ae 2054 NULL, 0, 16, 16, aead_speed_template_20_28_36);
4431bd49
GBY		 2055 test_aead_speed("gcm(aes)", DECRYPT, sec,
2056 NULL, 0, 16, 8, speed_template_16_24_32);
53f52d7a
TC		 2057 break;
2058
4e4aab63
HX		 2059 case 212:
2060 test_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec,
34a1c740 2061 NULL, 0, 16, 16, aead_speed_template_19);
4431bd49
GBY		 2062 test_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec,
2063 NULL, 0, 16, 16, aead_speed_template_19);
4e4aab63
HX		 2064 break;
2065
2dce063a
MW		 2066 case 213:
2067 test_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT, sec,
2068 NULL, 0, 16, 8, aead_speed_template_36);
4431bd49
GBY		 2069 test_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT, sec,
2070 NULL, 0, 16, 8, aead_speed_template_36);
2dce063a
MW		 2071 break;
2072
2073 case 214:
2074 test_cipher_speed("chacha20", ENCRYPT, sec, NULL, 0,
2075 speed_template_32);
2076 break;
2077
427988d9
GBY		 2078 case 215:
2079 test_mb_aead_speed("rfc4106(gcm(aes))", ENCRYPT, sec, NULL,
425359ae 2080 0, 16, 16, aead_speed_template_20_28_36, num_mb);
427988d9
GBY		 2081 test_mb_aead_speed("gcm(aes)", ENCRYPT, sec, NULL, 0, 16, 8,
2082 speed_template_16_24_32, num_mb);
2083 test_mb_aead_speed("rfc4106(gcm(aes))", DECRYPT, sec, NULL,
425359ae 2084 0, 16, 16, aead_speed_template_20_28_36, num_mb);
427988d9
GBY		 2085 test_mb_aead_speed("gcm(aes)", DECRYPT, sec, NULL, 0, 16, 8,
2086 speed_template_16_24_32, num_mb);
2087 break;
2088
2089 case 216:
2090 test_mb_aead_speed("rfc4309(ccm(aes))", ENCRYPT, sec, NULL, 0,
2091 16, 16, aead_speed_template_19, num_mb);
2092 test_mb_aead_speed("rfc4309(ccm(aes))", DECRYPT, sec, NULL, 0,
2093 16, 16, aead_speed_template_19, num_mb);
2094 break;
2095
2096 case 217:
2097 test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", ENCRYPT,
2098 sec, NULL, 0, 16, 8, aead_speed_template_36,
2099 num_mb);
2100 test_mb_aead_speed("rfc7539esp(chacha20,poly1305)", DECRYPT,
2101 sec, NULL, 0, 16, 8, aead_speed_template_36,
2102 num_mb);
2103 break;
2104
95ba5973
GBY		 2105 case 218:
2106 test_cipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0,
2107 speed_template_16);
2108 test_cipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0,
2109 speed_template_16);
2110 test_cipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0,
2111 speed_template_16);
2112 test_cipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0,
2113 speed_template_16);
3c383637
TZ		 2114 test_cipher_speed("cts(cbc(sm4))", ENCRYPT, sec, NULL, 0,
2115 speed_template_16);
2116 test_cipher_speed("cts(cbc(sm4))", DECRYPT, sec, NULL, 0,
2117 speed_template_16);
a7fc80bb
TZ		 2118 test_cipher_speed("cfb(sm4)", ENCRYPT, sec, NULL, 0,
2119 speed_template_16);
2120 test_cipher_speed("cfb(sm4)", DECRYPT, sec, NULL, 0,
2121 speed_template_16);
95ba5973
GBY		 2122 test_cipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0,
2123 speed_template_16);
2124 test_cipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0,
2125 speed_template_16);
3c383637
TZ		 2126 test_cipher_speed("xts(sm4)", ENCRYPT, sec, NULL, 0,
2127 speed_template_32);
2128 test_cipher_speed("xts(sm4)", DECRYPT, sec, NULL, 0,
2129 speed_template_32);
95ba5973 2130 break;
059c2a4d
EB		 2131
2132 case 219:
2133 test_cipher_speed("adiantum(xchacha12,aes)", ENCRYPT, sec, NULL,
2134 0, speed_template_32);
2135 test_cipher_speed("adiantum(xchacha12,aes)", DECRYPT, sec, NULL,
2136 0, speed_template_32);
2137 test_cipher_speed("adiantum(xchacha20,aes)", ENCRYPT, sec, NULL,
2138 0, speed_template_32);
2139 test_cipher_speed("adiantum(xchacha20,aes)", DECRYPT, sec, NULL,
2140 0, speed_template_32);
2141 break;
2142
f975abb2
AB		 2143 case 220:
2144 test_acipher_speed("essiv(cbc(aes),sha256)",
2145 ENCRYPT, sec, NULL, 0,
2146 speed_template_16_24_32);
2147 test_acipher_speed("essiv(cbc(aes),sha256)",
2148 DECRYPT, sec, NULL, 0,
2149 speed_template_16_24_32);
2150 break;
2151
97bcb161
AB		 2152 case 221:
2153 test_aead_speed("aegis128", ENCRYPT, sec,
2154 NULL, 0, 16, 8, speed_template_16);
2155 test_aead_speed("aegis128", DECRYPT, sec,
2156 NULL, 0, 16, 8, speed_template_16);
2157 break;
2158
357a753f
TZ		 2159 case 222:
2160 test_aead_speed("gcm(sm4)", ENCRYPT, sec,
2161 NULL, 0, 16, 8, speed_template_16);
2162 test_aead_speed("gcm(sm4)", DECRYPT, sec,
2163 NULL, 0, 16, 8, speed_template_16);
2164 break;
2165
2166 case 223:
2167 test_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec,
2168 NULL, 0, 16, 16, aead_speed_template_19);
2169 test_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec,
2170 NULL, 0, 16, 16, aead_speed_template_19);
2171 break;
2172
2173 case 224:
2174 test_mb_aead_speed("gcm(sm4)", ENCRYPT, sec, NULL, 0, 16, 8,
2175 speed_template_16, num_mb);
2176 test_mb_aead_speed("gcm(sm4)", DECRYPT, sec, NULL, 0, 16, 8,
2177 speed_template_16, num_mb);
2178 break;
2179
2180 case 225:
2181 test_mb_aead_speed("rfc4309(ccm(sm4))", ENCRYPT, sec, NULL, 0,
2182 16, 16, aead_speed_template_19, num_mb);
2183 test_mb_aead_speed("rfc4309(ccm(sm4))", DECRYPT, sec, NULL, 0,
2184 16, 16, aead_speed_template_19, num_mb);
2185 break;
2186
7ff554ce
NH		 2187 case 226:
2188 test_cipher_speed("hctr2(aes)", ENCRYPT, sec, NULL,
2189 0, speed_template_32);
2190 break;
2191
01ce31de
TY		 2192 case 227:
2193 test_cipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0,
2194 speed_template_16_24_32);
2195 test_cipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0,
2196 speed_template_16_24_32);
2197 test_cipher_speed("cbc(aria)", ENCRYPT, sec, NULL, 0,
2198 speed_template_16_24_32);
2199 test_cipher_speed("cbc(aria)", DECRYPT, sec, NULL, 0,
2200 speed_template_16_24_32);
2201 test_cipher_speed("cfb(aria)", ENCRYPT, sec, NULL, 0,
2202 speed_template_16_24_32);
2203 test_cipher_speed("cfb(aria)", DECRYPT, sec, NULL, 0,
2204 speed_template_16_24_32);
2205 test_cipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0,
2206 speed_template_16_24_32);
2207 test_cipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0,
2208 speed_template_16_24_32);
2209 break;
2210
2211 case 228:
2212 test_aead_speed("gcm(aria)", ENCRYPT, sec,
2213 NULL, 0, 16, 8, speed_template_16_24_32);
2214 test_aead_speed("gcm(aria)", DECRYPT, sec,
2215 NULL, 0, 16, 8, speed_template_16_24_32);
2216 break;
2217
c4b1ce72
TY		 2218 case 229:
2219 test_mb_aead_speed("gcm(aria)", ENCRYPT, sec, NULL, 0, 16, 8,
2220 speed_template_16, num_mb);
2221 test_mb_aead_speed("gcm(aria)", DECRYPT, sec, NULL, 0, 16, 8,
2222 speed_template_16, num_mb);
2223 break;
2224
e8057928 2225 case 300:
8606813a
HX		 2226 if (alg) {
2227 test_hash_speed(alg, sec, generic_hash_speed_template);
2228 break;
2229 }
df561f66 2230 fallthrough;
e8057928 2231 case 301:
e9d41164 2232 test_hash_speed("md4", sec, generic_hash_speed_template);
e8057928 2233 if (mode > 300 && mode < 400) break;
df561f66 2234 fallthrough;
e8057928 2235 case 302:
e9d41164 2236 test_hash_speed("md5", sec, generic_hash_speed_template);
e8057928 2237 if (mode > 300 && mode < 400) break;
df561f66 2238 fallthrough;
e8057928 2239 case 303:
e9d41164 2240 test_hash_speed("sha1", sec, generic_hash_speed_template);
e8057928 2241 if (mode > 300 && mode < 400) break;
df561f66 2242 fallthrough;
e8057928 2243 case 304:
e9d41164 2244 test_hash_speed("sha256", sec, generic_hash_speed_template);
e8057928 2245 if (mode > 300 && mode < 400) break;
df561f66 2246 fallthrough;
e8057928 2247 case 305:
e9d41164 2248 test_hash_speed("sha384", sec, generic_hash_speed_template);
e8057928 2249 if (mode > 300 && mode < 400) break;
df561f66 2250 fallthrough;
e8057928 2251 case 306:
e9d41164 2252 test_hash_speed("sha512", sec, generic_hash_speed_template);
e8057928 2253 if (mode > 300 && mode < 400) break;
df561f66 2254 fallthrough;
e8057928 2255 case 307:
e9d41164 2256 test_hash_speed("wp256", sec, generic_hash_speed_template);
e8057928 2257 if (mode > 300 && mode < 400) break;
df561f66 2258 fallthrough;
e8057928 2259 case 308:
e9d41164 2260 test_hash_speed("wp384", sec, generic_hash_speed_template);
e8057928 2261 if (mode > 300 && mode < 400) break;
df561f66 2262 fallthrough;
e8057928 2263 case 309:
e9d41164 2264 test_hash_speed("wp512", sec, generic_hash_speed_template);
e8057928 2265 if (mode > 300 && mode < 400) break;
df561f66 2266 fallthrough;
cd12fb90
JL		 2267 case 313:
2268 test_hash_speed("sha224", sec, generic_hash_speed_template);
2269 if (mode > 300 && mode < 400) break;
df561f66 2270 fallthrough;
aa22cd7f
AB		 2271 case 314:
2272 test_hash_speed("xxhash64", sec, generic_hash_speed_template);
2273 if (mode > 300 && mode < 400) break;
2274 fallthrough;
fd4adf1a
AKR		 2275 case 315:
2276 test_hash_speed("rmd160", sec, generic_hash_speed_template);
2277 if (mode > 300 && mode < 400) break;
df561f66 2278 fallthrough;
aa22cd7f
AB		 2279 case 317:
2280 test_hash_speed("blake2b-512", sec, generic_hash_speed_template);
2281 if (mode > 300 && mode < 400) break;
2282 fallthrough;
18bcc919 2283 case 318:
ba974adb
HX		 2284 klen = 16;
2285 test_hash_speed("ghash", sec, generic_hash_speed_template);
18bcc919 2286 if (mode > 300 && mode < 400) break;
df561f66 2287 fallthrough;
e3899e4d
TC		 2288 case 319:
2289 test_hash_speed("crc32c", sec, generic_hash_speed_template);
2290 if (mode > 300 && mode < 400) break;
df561f66 2291 fallthrough;
68411521
HX		 2292 case 320:
2293 test_hash_speed("crct10dif", sec, generic_hash_speed_template);
2294 if (mode > 300 && mode < 400) break;
df561f66 2295 fallthrough;
2dce063a
MW		 2296 case 321:
2297 test_hash_speed("poly1305", sec, poly1305_speed_template);
2298 if (mode > 300 && mode < 400) break;
df561f66 2299 fallthrough;
79cc6ab8 2300 case 322:
2301 test_hash_speed("sha3-224", sec, generic_hash_speed_template);
2302 if (mode > 300 && mode < 400) break;
df561f66 2303 fallthrough;
79cc6ab8 2304 case 323:
2305 test_hash_speed("sha3-256", sec, generic_hash_speed_template);
2306 if (mode > 300 && mode < 400) break;
df561f66 2307 fallthrough;
79cc6ab8 2308 case 324:
2309 test_hash_speed("sha3-384", sec, generic_hash_speed_template);
2310 if (mode > 300 && mode < 400) break;
df561f66 2311 fallthrough;
79cc6ab8 2312 case 325:
2313 test_hash_speed("sha3-512", sec, generic_hash_speed_template);
2314 if (mode > 300 && mode < 400) break;
df561f66 2315 fallthrough;
b7e27530
GBY		 2316 case 326:
2317 test_hash_speed("sm3", sec, generic_hash_speed_template);
2318 if (mode > 300 && mode < 400) break;
df561f66 2319 fallthrough;
25a0b9d4
VC		 2320 case 327:
2321 test_hash_speed("streebog256", sec,
2322 generic_hash_speed_template);
2323 if (mode > 300 && mode < 400) break;
df561f66 2324 fallthrough;
25a0b9d4
VC		 2325 case 328:
2326 test_hash_speed("streebog512", sec,
2327 generic_hash_speed_template);
2328 if (mode > 300 && mode < 400) break;
df561f66 2329 fallthrough;
e8057928
ML		 2330 case 399:
2331 break;
2332
beb63da7 2333 case 400:
8606813a
HX		 2334 if (alg) {
2335 test_ahash_speed(alg, sec, generic_hash_speed_template);
2336 break;
2337 }
df561f66 2338 fallthrough;
beb63da7
DM		 2339 case 401:
2340 test_ahash_speed("md4", sec, generic_hash_speed_template);
2341 if (mode > 400 && mode < 500) break;
df561f66 2342 fallthrough;
beb63da7
DM		 2343 case 402:
2344 test_ahash_speed("md5", sec, generic_hash_speed_template);
2345 if (mode > 400 && mode < 500) break;
df561f66 2346 fallthrough;
beb63da7
DM		 2347 case 403:
2348 test_ahash_speed("sha1", sec, generic_hash_speed_template);
2349 if (mode > 400 && mode < 500) break;
df561f66 2350 fallthrough;
beb63da7
DM		 2351 case 404:
2352 test_ahash_speed("sha256", sec, generic_hash_speed_template);
2353 if (mode > 400 && mode < 500) break;
df561f66 2354 fallthrough;
beb63da7
DM		 2355 case 405:
2356 test_ahash_speed("sha384", sec, generic_hash_speed_template);
2357 if (mode > 400 && mode < 500) break;
df561f66 2358 fallthrough;
beb63da7
DM		 2359 case 406:
2360 test_ahash_speed("sha512", sec, generic_hash_speed_template);
2361 if (mode > 400 && mode < 500) break;
df561f66 2362 fallthrough;
beb63da7
DM		 2363 case 407:
2364 test_ahash_speed("wp256", sec, generic_hash_speed_template);
2365 if (mode > 400 && mode < 500) break;
df561f66 2366 fallthrough;
beb63da7
DM		 2367 case 408:
2368 test_ahash_speed("wp384", sec, generic_hash_speed_template);
2369 if (mode > 400 && mode < 500) break;
df561f66 2370 fallthrough;
beb63da7
DM		 2371 case 409:
2372 test_ahash_speed("wp512", sec, generic_hash_speed_template);
2373 if (mode > 400 && mode < 500) break;
df561f66 2374 fallthrough;
beb63da7
DM		 2375 case 413:
2376 test_ahash_speed("sha224", sec, generic_hash_speed_template);
2377 if (mode > 400 && mode < 500) break;
df561f66 2378 fallthrough;
aa22cd7f
AB		 2379 case 414:
2380 test_ahash_speed("xxhash64", sec, generic_hash_speed_template);
2381 if (mode > 400 && mode < 500) break;
2382 fallthrough;
beb63da7
DM		 2383 case 415:
2384 test_ahash_speed("rmd160", sec, generic_hash_speed_template);
2385 if (mode > 400 && mode < 500) break;
df561f66 2386 fallthrough;
aa22cd7f
AB		 2387 case 417:
2388 test_ahash_speed("blake2b-512", sec, generic_hash_speed_template);
2389 if (mode > 400 && mode < 500) break;
2390 fallthrough;
79cc6ab8 2391 case 418:
2392 test_ahash_speed("sha3-224", sec, generic_hash_speed_template);
2393 if (mode > 400 && mode < 500) break;
df561f66 2394 fallthrough;
79cc6ab8 2395 case 419:
2396 test_ahash_speed("sha3-256", sec, generic_hash_speed_template);
2397 if (mode > 400 && mode < 500) break;
df561f66 2398 fallthrough;
79cc6ab8 2399 case 420:
2400 test_ahash_speed("sha3-384", sec, generic_hash_speed_template);
2401 if (mode > 400 && mode < 500) break;
df561f66 2402 fallthrough;
79cc6ab8 2403 case 421:
2404 test_ahash_speed("sha3-512", sec, generic_hash_speed_template);
2405 if (mode > 400 && mode < 500) break;
df561f66 2406 fallthrough;
087bcd22 2407 case 422:
ba2c149d
TZ		 2408 test_ahash_speed("sm3", sec, generic_hash_speed_template);
2409 if (mode > 400 && mode < 500) break;
df561f66 2410 fallthrough;
beb63da7
DM		 2411 case 499:
2412 break;
2413
3f3baf35
JK		 2414 case 500:
2415 test_acipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
2416 speed_template_16_24_32);
2417 test_acipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
2418 speed_template_16_24_32);
2419 test_acipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
2420 speed_template_16_24_32);
2421 test_acipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
2422 speed_template_16_24_32);
2423 test_acipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
2424 speed_template_32_40_48);
2425 test_acipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
2426 speed_template_32_40_48);
2427 test_acipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
b66ad0b7 2428 speed_template_32_64);
3f3baf35 2429 test_acipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
b66ad0b7 2430 speed_template_32_64);
1503a24f
HX		 2431 test_acipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
2432 speed_template_16_24_32);
2433 test_acipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
2434 speed_template_16_24_32);
3f3baf35
JK		 2435 test_acipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
2436 speed_template_16_24_32);
2437 test_acipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
2438 speed_template_16_24_32);
de197533
NR		 2439 test_acipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
2440 speed_template_16_24_32);
2441 test_acipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
2442 speed_template_16_24_32);
2443 test_acipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
2444 speed_template_16_24_32);
2445 test_acipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
2446 speed_template_16_24_32);
69d3150c
JK		 2447 test_acipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL, 0,
2448 speed_template_20_28_36);
2449 test_acipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL, 0,
2450 speed_template_20_28_36);
3f3baf35
JK		 2451 break;
2452
2453 case 501:
2454 test_acipher_speed("ecb(des3_ede)", ENCRYPT, sec,
2455 des3_speed_template, DES3_SPEED_VECTORS,
2456 speed_template_24);
2457 test_acipher_speed("ecb(des3_ede)", DECRYPT, sec,
2458 des3_speed_template, DES3_SPEED_VECTORS,
2459 speed_template_24);
2460 test_acipher_speed("cbc(des3_ede)", ENCRYPT, sec,
2461 des3_speed_template, DES3_SPEED_VECTORS,
2462 speed_template_24);
2463 test_acipher_speed("cbc(des3_ede)", DECRYPT, sec,
2464 des3_speed_template, DES3_SPEED_VECTORS,
2465 speed_template_24);
de197533
NR		 2466 test_acipher_speed("cfb(des3_ede)", ENCRYPT, sec,
2467 des3_speed_template, DES3_SPEED_VECTORS,
2468 speed_template_24);
2469 test_acipher_speed("cfb(des3_ede)", DECRYPT, sec,
2470 des3_speed_template, DES3_SPEED_VECTORS,
2471 speed_template_24);
2472 test_acipher_speed("ofb(des3_ede)", ENCRYPT, sec,
2473 des3_speed_template, DES3_SPEED_VECTORS,
2474 speed_template_24);
2475 test_acipher_speed("ofb(des3_ede)", DECRYPT, sec,
2476 des3_speed_template, DES3_SPEED_VECTORS,
2477 speed_template_24);
3f3baf35
JK		 2478 break;
2479
2480 case 502:
2481 test_acipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
2482 speed_template_8);
2483 test_acipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
2484 speed_template_8);
2485 test_acipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
2486 speed_template_8);
2487 test_acipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
2488 speed_template_8);
de197533
NR		 2489 test_acipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
2490 speed_template_8);
2491 test_acipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
2492 speed_template_8);
2493 test_acipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
2494 speed_template_8);
2495 test_acipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
2496 speed_template_8);
3f3baf35
JK		 2497 break;
2498
7fb7fe44
JK		 2499 case 503:
2500 test_acipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
2501 speed_template_16_32);
2502 test_acipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
2503 speed_template_16_32);
2504 test_acipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2505 speed_template_16_32);
2506 test_acipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2507 speed_template_16_32);
2508 test_acipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2509 speed_template_16_32);
2510 test_acipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2511 speed_template_16_32);
87aae4bf
JK		 2512 test_acipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2513 speed_template_32_48);
2514 test_acipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2515 speed_template_32_48);
5209c07a
JK		 2516 test_acipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2517 speed_template_32_64);
2518 test_acipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2519 speed_template_32_64);
7fb7fe44
JK		 2520 break;
2521
107778b5
JG		 2522 case 504:
2523 test_acipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2524 speed_template_16_24_32);
2525 test_acipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2526 speed_template_16_24_32);
2527 test_acipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2528 speed_template_16_24_32);
2529 test_acipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2530 speed_template_16_24_32);
2531 test_acipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2532 speed_template_16_24_32);
2533 test_acipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2534 speed_template_16_24_32);
2535 test_acipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2536 speed_template_32_40_48);
2537 test_acipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2538 speed_template_32_40_48);
2539 test_acipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2540 speed_template_32_48_64);
2541 test_acipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2542 speed_template_32_48_64);
2543 break;
2544
31b4cd29
JK		 2545 case 505:
2546 test_acipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2547 speed_template_8);
2548 break;
2549
a2c58260
JG		 2550 case 506:
2551 test_acipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2552 speed_template_8_16);
2553 test_acipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2554 speed_template_8_16);
2555 test_acipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2556 speed_template_8_16);
2557 test_acipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2558 speed_template_8_16);
2559 test_acipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2560 speed_template_8_16);
2561 test_acipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2562 speed_template_8_16);
2563 break;
2564
9b8b0405
JG		 2565 case 507:
2566 test_acipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2567 speed_template_16_32);
2568 test_acipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2569 speed_template_16_32);
2570 test_acipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2571 speed_template_16_32);
2572 test_acipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2573 speed_template_16_32);
2574 test_acipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2575 speed_template_16_32);
2576 test_acipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2577 speed_template_16_32);
2578 test_acipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2579 speed_template_32_48);
2580 test_acipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2581 speed_template_32_48);
2582 test_acipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2583 speed_template_32_64);
2584 test_acipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2585 speed_template_32_64);
2586 break;
2587
bf9c5181
JK		 2588 case 508:
2589 test_acipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2590 speed_template_16_32);
2591 test_acipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2592 speed_template_16_32);
2593 test_acipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2594 speed_template_16_32);
2595 test_acipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2596 speed_template_16_32);
2597 test_acipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2598 speed_template_16_32);
2599 test_acipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2600 speed_template_16_32);
2601 test_acipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2602 speed_template_32_48);
2603 test_acipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2604 speed_template_32_48);
2605 test_acipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2606 speed_template_32_64);
2607 test_acipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2608 speed_template_32_64);
2609 break;
2610
ad8b7c3e
JK		 2611 case 509:
2612 test_acipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2613 speed_template_8_32);
2614 test_acipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2615 speed_template_8_32);
2616 test_acipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2617 speed_template_8_32);
2618 test_acipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2619 speed_template_8_32);
2620 test_acipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2621 speed_template_8_32);
2622 test_acipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2623 speed_template_8_32);
2624 break;
2625
a7fc80bb
TZ		 2626 case 518:
2627 test_acipher_speed("ecb(sm4)", ENCRYPT, sec, NULL, 0,
2628 speed_template_16);
2629 test_acipher_speed("ecb(sm4)", DECRYPT, sec, NULL, 0,
2630 speed_template_16);
2631 test_acipher_speed("cbc(sm4)", ENCRYPT, sec, NULL, 0,
2632 speed_template_16);
2633 test_acipher_speed("cbc(sm4)", DECRYPT, sec, NULL, 0,
2634 speed_template_16);
2635 test_acipher_speed("cfb(sm4)", ENCRYPT, sec, NULL, 0,
2636 speed_template_16);
2637 test_acipher_speed("cfb(sm4)", DECRYPT, sec, NULL, 0,
2638 speed_template_16);
2639 test_acipher_speed("ctr(sm4)", ENCRYPT, sec, NULL, 0,
2640 speed_template_16);
2641 test_acipher_speed("ctr(sm4)", DECRYPT, sec, NULL, 0,
2642 speed_template_16);
3c383637
TZ		 2643 test_acipher_speed("xts(sm4)", ENCRYPT, sec, NULL, 0,
2644 speed_template_32);
2645 test_acipher_speed("xts(sm4)", DECRYPT, sec, NULL, 0,
2646 speed_template_32);
a7fc80bb
TZ		 2647 break;
2648
c4b1ce72
TY		 2649 case 519:
2650 test_acipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0,
2651 speed_template_16_24_32);
2652 test_acipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0,
2653 speed_template_16_24_32);
2654 test_acipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0,
2655 speed_template_16_24_32);
2656 test_acipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0,
2657 speed_template_16_24_32);
2658 break;
2659
e161c593
GBY		 2660 case 600:
2661 test_mb_skcipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
2662 speed_template_16_24_32, num_mb);
2663 test_mb_skcipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
2664 speed_template_16_24_32, num_mb);
2665 test_mb_skcipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
2666 speed_template_16_24_32, num_mb);
2667 test_mb_skcipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
2668 speed_template_16_24_32, num_mb);
2669 test_mb_skcipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
2670 speed_template_32_40_48, num_mb);
2671 test_mb_skcipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
2672 speed_template_32_40_48, num_mb);
2673 test_mb_skcipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
2674 speed_template_32_64, num_mb);
2675 test_mb_skcipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
2676 speed_template_32_64, num_mb);
2677 test_mb_skcipher_speed("cts(cbc(aes))", ENCRYPT, sec, NULL, 0,
2678 speed_template_16_24_32, num_mb);
2679 test_mb_skcipher_speed("cts(cbc(aes))", DECRYPT, sec, NULL, 0,
2680 speed_template_16_24_32, num_mb);
2681 test_mb_skcipher_speed("ctr(aes)", ENCRYPT, sec, NULL, 0,
2682 speed_template_16_24_32, num_mb);
2683 test_mb_skcipher_speed("ctr(aes)", DECRYPT, sec, NULL, 0,
2684 speed_template_16_24_32, num_mb);
2685 test_mb_skcipher_speed("cfb(aes)", ENCRYPT, sec, NULL, 0,
2686 speed_template_16_24_32, num_mb);
2687 test_mb_skcipher_speed("cfb(aes)", DECRYPT, sec, NULL, 0,
2688 speed_template_16_24_32, num_mb);
2689 test_mb_skcipher_speed("ofb(aes)", ENCRYPT, sec, NULL, 0,
2690 speed_template_16_24_32, num_mb);
2691 test_mb_skcipher_speed("ofb(aes)", DECRYPT, sec, NULL, 0,
2692 speed_template_16_24_32, num_mb);
2693 test_mb_skcipher_speed("rfc3686(ctr(aes))", ENCRYPT, sec, NULL,
2694 0, speed_template_20_28_36, num_mb);
2695 test_mb_skcipher_speed("rfc3686(ctr(aes))", DECRYPT, sec, NULL,
2696 0, speed_template_20_28_36, num_mb);
2697 break;
2698
2699 case 601:
2700 test_mb_skcipher_speed("ecb(des3_ede)", ENCRYPT, sec,
2701 des3_speed_template, DES3_SPEED_VECTORS,
2702 speed_template_24, num_mb);
2703 test_mb_skcipher_speed("ecb(des3_ede)", DECRYPT, sec,
2704 des3_speed_template, DES3_SPEED_VECTORS,
2705 speed_template_24, num_mb);
2706 test_mb_skcipher_speed("cbc(des3_ede)", ENCRYPT, sec,
2707 des3_speed_template, DES3_SPEED_VECTORS,
2708 speed_template_24, num_mb);
2709 test_mb_skcipher_speed("cbc(des3_ede)", DECRYPT, sec,
2710 des3_speed_template, DES3_SPEED_VECTORS,
2711 speed_template_24, num_mb);
2712 test_mb_skcipher_speed("cfb(des3_ede)", ENCRYPT, sec,
2713 des3_speed_template, DES3_SPEED_VECTORS,
2714 speed_template_24, num_mb);
2715 test_mb_skcipher_speed("cfb(des3_ede)", DECRYPT, sec,
2716 des3_speed_template, DES3_SPEED_VECTORS,
2717 speed_template_24, num_mb);
2718 test_mb_skcipher_speed("ofb(des3_ede)", ENCRYPT, sec,
2719 des3_speed_template, DES3_SPEED_VECTORS,
2720 speed_template_24, num_mb);
2721 test_mb_skcipher_speed("ofb(des3_ede)", DECRYPT, sec,
2722 des3_speed_template, DES3_SPEED_VECTORS,
2723 speed_template_24, num_mb);
2724 break;
2725
2726 case 602:
2727 test_mb_skcipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
2728 speed_template_8, num_mb);
2729 test_mb_skcipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
2730 speed_template_8, num_mb);
2731 test_mb_skcipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
2732 speed_template_8, num_mb);
2733 test_mb_skcipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
2734 speed_template_8, num_mb);
2735 test_mb_skcipher_speed("cfb(des)", ENCRYPT, sec, NULL, 0,
2736 speed_template_8, num_mb);
2737 test_mb_skcipher_speed("cfb(des)", DECRYPT, sec, NULL, 0,
2738 speed_template_8, num_mb);
2739 test_mb_skcipher_speed("ofb(des)", ENCRYPT, sec, NULL, 0,
2740 speed_template_8, num_mb);
2741 test_mb_skcipher_speed("ofb(des)", DECRYPT, sec, NULL, 0,
2742 speed_template_8, num_mb);
2743 break;
2744
2745 case 603:
2746 test_mb_skcipher_speed("ecb(serpent)", ENCRYPT, sec, NULL, 0,
2747 speed_template_16_32, num_mb);
2748 test_mb_skcipher_speed("ecb(serpent)", DECRYPT, sec, NULL, 0,
2749 speed_template_16_32, num_mb);
2750 test_mb_skcipher_speed("cbc(serpent)", ENCRYPT, sec, NULL, 0,
2751 speed_template_16_32, num_mb);
2752 test_mb_skcipher_speed("cbc(serpent)", DECRYPT, sec, NULL, 0,
2753 speed_template_16_32, num_mb);
2754 test_mb_skcipher_speed("ctr(serpent)", ENCRYPT, sec, NULL, 0,
2755 speed_template_16_32, num_mb);
2756 test_mb_skcipher_speed("ctr(serpent)", DECRYPT, sec, NULL, 0,
2757 speed_template_16_32, num_mb);
2758 test_mb_skcipher_speed("lrw(serpent)", ENCRYPT, sec, NULL, 0,
2759 speed_template_32_48, num_mb);
2760 test_mb_skcipher_speed("lrw(serpent)", DECRYPT, sec, NULL, 0,
2761 speed_template_32_48, num_mb);
2762 test_mb_skcipher_speed("xts(serpent)", ENCRYPT, sec, NULL, 0,
2763 speed_template_32_64, num_mb);
2764 test_mb_skcipher_speed("xts(serpent)", DECRYPT, sec, NULL, 0,
2765 speed_template_32_64, num_mb);
2766 break;
2767
2768 case 604:
2769 test_mb_skcipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
2770 speed_template_16_24_32, num_mb);
2771 test_mb_skcipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
2772 speed_template_16_24_32, num_mb);
2773 test_mb_skcipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
2774 speed_template_16_24_32, num_mb);
2775 test_mb_skcipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
2776 speed_template_16_24_32, num_mb);
2777 test_mb_skcipher_speed("ctr(twofish)", ENCRYPT, sec, NULL, 0,
2778 speed_template_16_24_32, num_mb);
2779 test_mb_skcipher_speed("ctr(twofish)", DECRYPT, sec, NULL, 0,
2780 speed_template_16_24_32, num_mb);
2781 test_mb_skcipher_speed("lrw(twofish)", ENCRYPT, sec, NULL, 0,
2782 speed_template_32_40_48, num_mb);
2783 test_mb_skcipher_speed("lrw(twofish)", DECRYPT, sec, NULL, 0,
2784 speed_template_32_40_48, num_mb);
2785 test_mb_skcipher_speed("xts(twofish)", ENCRYPT, sec, NULL, 0,
2786 speed_template_32_48_64, num_mb);
2787 test_mb_skcipher_speed("xts(twofish)", DECRYPT, sec, NULL, 0,
2788 speed_template_32_48_64, num_mb);
2789 break;
2790
2791 case 605:
2792 test_mb_skcipher_speed("ecb(arc4)", ENCRYPT, sec, NULL, 0,
2793 speed_template_8, num_mb);
2794 break;
2795
2796 case 606:
2797 test_mb_skcipher_speed("ecb(cast5)", ENCRYPT, sec, NULL, 0,
2798 speed_template_8_16, num_mb);
2799 test_mb_skcipher_speed("ecb(cast5)", DECRYPT, sec, NULL, 0,
2800 speed_template_8_16, num_mb);
2801 test_mb_skcipher_speed("cbc(cast5)", ENCRYPT, sec, NULL, 0,
2802 speed_template_8_16, num_mb);
2803 test_mb_skcipher_speed("cbc(cast5)", DECRYPT, sec, NULL, 0,
2804 speed_template_8_16, num_mb);
2805 test_mb_skcipher_speed("ctr(cast5)", ENCRYPT, sec, NULL, 0,
2806 speed_template_8_16, num_mb);
2807 test_mb_skcipher_speed("ctr(cast5)", DECRYPT, sec, NULL, 0,
2808 speed_template_8_16, num_mb);
2809 break;
2810
2811 case 607:
2812 test_mb_skcipher_speed("ecb(cast6)", ENCRYPT, sec, NULL, 0,
2813 speed_template_16_32, num_mb);
2814 test_mb_skcipher_speed("ecb(cast6)", DECRYPT, sec, NULL, 0,
2815 speed_template_16_32, num_mb);
2816 test_mb_skcipher_speed("cbc(cast6)", ENCRYPT, sec, NULL, 0,
2817 speed_template_16_32, num_mb);
2818 test_mb_skcipher_speed("cbc(cast6)", DECRYPT, sec, NULL, 0,
2819 speed_template_16_32, num_mb);
2820 test_mb_skcipher_speed("ctr(cast6)", ENCRYPT, sec, NULL, 0,
2821 speed_template_16_32, num_mb);
2822 test_mb_skcipher_speed("ctr(cast6)", DECRYPT, sec, NULL, 0,
2823 speed_template_16_32, num_mb);
2824 test_mb_skcipher_speed("lrw(cast6)", ENCRYPT, sec, NULL, 0,
2825 speed_template_32_48, num_mb);
2826 test_mb_skcipher_speed("lrw(cast6)", DECRYPT, sec, NULL, 0,
2827 speed_template_32_48, num_mb);
2828 test_mb_skcipher_speed("xts(cast6)", ENCRYPT, sec, NULL, 0,
2829 speed_template_32_64, num_mb);
2830 test_mb_skcipher_speed("xts(cast6)", DECRYPT, sec, NULL, 0,
2831 speed_template_32_64, num_mb);
2832 break;
2833
2834 case 608:
2835 test_mb_skcipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
2836 speed_template_16_32, num_mb);
2837 test_mb_skcipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
2838 speed_template_16_32, num_mb);
2839 test_mb_skcipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
2840 speed_template_16_32, num_mb);
2841 test_mb_skcipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
2842 speed_template_16_32, num_mb);
2843 test_mb_skcipher_speed("ctr(camellia)", ENCRYPT, sec, NULL, 0,
2844 speed_template_16_32, num_mb);
2845 test_mb_skcipher_speed("ctr(camellia)", DECRYPT, sec, NULL, 0,
2846 speed_template_16_32, num_mb);
2847 test_mb_skcipher_speed("lrw(camellia)", ENCRYPT, sec, NULL, 0,
2848 speed_template_32_48, num_mb);
2849 test_mb_skcipher_speed("lrw(camellia)", DECRYPT, sec, NULL, 0,
2850 speed_template_32_48, num_mb);
2851 test_mb_skcipher_speed("xts(camellia)", ENCRYPT, sec, NULL, 0,
2852 speed_template_32_64, num_mb);
2853 test_mb_skcipher_speed("xts(camellia)", DECRYPT, sec, NULL, 0,
2854 speed_template_32_64, num_mb);
2855 break;
2856
2857 case 609:
2858 test_mb_skcipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
2859 speed_template_8_32, num_mb);
2860 test_mb_skcipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
2861 speed_template_8_32, num_mb);
2862 test_mb_skcipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
2863 speed_template_8_32, num_mb);
2864 test_mb_skcipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
2865 speed_template_8_32, num_mb);
2866 test_mb_skcipher_speed("ctr(blowfish)", ENCRYPT, sec, NULL, 0,
2867 speed_template_8_32, num_mb);
2868 test_mb_skcipher_speed("ctr(blowfish)", DECRYPT, sec, NULL, 0,
2869 speed_template_8_32, num_mb);
2870 break;
c4b1ce72
TY		 2871
2872 case 610:
2873 test_mb_skcipher_speed("ecb(aria)", ENCRYPT, sec, NULL, 0,
2874 speed_template_16_32, num_mb);
2875 test_mb_skcipher_speed("ecb(aria)", DECRYPT, sec, NULL, 0,
2876 speed_template_16_32, num_mb);
2877 test_mb_skcipher_speed("ctr(aria)", ENCRYPT, sec, NULL, 0,
2878 speed_template_16_32, num_mb);
2879 test_mb_skcipher_speed("ctr(aria)", DECRYPT, sec, NULL, 0,
2880 speed_template_16_32, num_mb);
2881 break;
2882
1da177e4 2883 }
4e033a6b
JW		 2884
2885 return ret;
1da177e4
LT		 2886}
2887
3af5b90b 2888static int __init tcrypt_mod_init(void)
1da177e4 2889{
e3a4ea4f 2890 int err = -ENOMEM;
f139cfa7 2891 int i;
e3a4ea4f 2892
f139cfa7
HX		 2893 for (i = 0; i < TVMEMSIZE; i++) {
2894 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
2895 if (!tvmem[i])
2896 goto err_free_tv;
2897 }
1da177e4 2898
4e234eed 2899 err = do_test(alg, type, mask, mode, num_mb);
a873a5f1 2900
4e033a6b 2901 if (err) {
837a99f5 2902 pr_err("one or more tests failed!\n");
4e033a6b 2903 goto err_free_tv;
76512f2d
RV		 2904 } else {
2905 pr_debug("all tests passed\n");
4e033a6b 2906 }
14fdf477 2907
4e033a6b
JW		 2908 /* We intentionaly return -EAGAIN to prevent keeping the module,
2909 * unless we're running in fips mode. It does all its work from
2910 * init() and doesn't offer any runtime functionality, but in
2911 * the fips case, checking for a successful load is helpful.
14fdf477
ML		 2912 * => we don't need it in the memory, do we?
2913 * -- mludvig
2914 */
4e033a6b
JW		 2915 if (!fips_enabled)
2916 err = -EAGAIN;
e3a4ea4f 2917
f139cfa7
HX		 2918err_free_tv:
2919 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
2920 free_page((unsigned long)tvmem[i]);
e3a4ea4f
MH		 2921
2922 return err;
1da177e4
LT		 2923}
2924
2925/*
2926 * If an init function is provided, an exit function must also be provided
2927 * to allow module unload.
2928 */
3af5b90b 2929static void __exit tcrypt_mod_fini(void) { }
1da177e4 2930
08a7e33c 2931late_initcall(tcrypt_mod_init);
3af5b90b 2932module_exit(tcrypt_mod_fini);
1da177e4 2933
a873a5f1
SK		 2934module_param(alg, charp, 0);
2935module_param(type, uint, 0);
7be380f7 2936module_param(mask, uint, 0);
1da177e4 2937module_param(mode, int, 0);
ebfd9bcf 2938module_param(sec, uint, 0);
6a17944c
HX		 2939MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
2940 "(defaults to zero which uses CPU cycles instead)");
8fcdc868
GBY		 2941module_param(num_mb, uint, 0000);
2942MODULE_PARM_DESC(num_mb, "Number of concurrent requests to be used in mb speed tests (defaults to 8)");
ba974adb
HX		 2943module_param(klen, uint, 0);
2944MODULE_PARM_DESC(klen, "Key length (defaults to 0)");
1da177e4
LT		 2945
2946MODULE_LICENSE("GPL");
2947MODULE_DESCRIPTION("Quick & dirty crypto testing module");
2948MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
Linux 6.x block layer and io_uring tree(s)