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