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