blob: 28a45a1e6f423603a563ef40c821736a88ef266b [file] [log] [blame]
Herbert Xuef2736f2005-06-22 13:26:03 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * 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>
Mikko Herranene3a4ea42007-11-26 22:12:07 +08009 * Copyright (c) 2007 Nokia Siemens Networks
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the Free
Herbert Xuef2736f2005-06-22 13:26:03 -070013 * Software Foundation; either version 2 of the License, or (at your option)
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 * any later version.
15 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 */
17
Herbert Xu18e33e62008-07-10 16:01:22 +080018#include <crypto/hash.h>
Herbert Xucba83562006-08-13 08:26:09 +100019#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/init.h>
21#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/slab.h>
David Hardeman378f0582005-09-17 17:55:31 +100023#include <linux/scatterlist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/moduleparam.h>
Harald Welteebfd9bc2005-06-22 13:27:23 -070026#include <linux/jiffies.h>
Herbert Xu6a179442005-06-22 13:29:03 -070027#include <linux/timex.h>
28#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "tcrypt.h"
30
31/*
Herbert Xuf139cfa2008-07-31 12:23:53 +080032 * Need slab memory for testing (size in number of pages).
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 */
Herbert Xuf139cfa2008-07-31 12:23:53 +080034#define TVMEMSIZE 4
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36/*
Herbert Xuda7f0332008-07-31 17:08:25 +080037* Used by test_cipher_speed()
Linus Torvalds1da177e2005-04-16 15:20:36 -070038*/
39#define ENCRYPT 1
40#define DECRYPT 0
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Harald Welteebfd9bc2005-06-22 13:27:23 -070042/*
43 * Used by test_cipher_speed()
44 */
Herbert Xu6a179442005-06-22 13:29:03 -070045static unsigned int sec;
Harald Welteebfd9bc2005-06-22 13:27:23 -070046
Linus Torvalds1da177e2005-04-16 15:20:36 -070047static int mode;
Herbert Xuf139cfa2008-07-31 12:23:53 +080048static char *tvmem[TVMEMSIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50static char *check[] = {
Jonathan Lynchcd12fb92007-11-10 20:08:25 +080051 "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256",
52 "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes",
53 "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
David Howells90831632006-12-16 12:13:14 +110054 "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt",
Adrian-Ken Rueegsegger2998db32008-05-09 21:29:35 +080055 "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320",
56 "lzo", "cts", NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -070057};
58
Herbert Xuf139cfa2008-07-31 12:23:53 +080059static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
60 struct scatterlist *sg, int blen, int sec)
Herbert Xu6a179442005-06-22 13:29:03 -070061{
Herbert Xu6a179442005-06-22 13:29:03 -070062 unsigned long start, end;
63 int bcount;
64 int ret;
65
Herbert Xu6a179442005-06-22 13:29:03 -070066 for (start = jiffies, end = start + sec * HZ, bcount = 0;
67 time_before(jiffies, end); bcount++) {
68 if (enc)
Herbert Xucba83562006-08-13 08:26:09 +100069 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -070070 else
Herbert Xucba83562006-08-13 08:26:09 +100071 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -070072
73 if (ret)
74 return ret;
75 }
76
77 printk("%d operations in %d seconds (%ld bytes)\n",
78 bcount, sec, (long)bcount * blen);
79 return 0;
80}
81
Herbert Xuf139cfa2008-07-31 12:23:53 +080082static int test_cipher_cycles(struct blkcipher_desc *desc, int enc,
83 struct scatterlist *sg, int blen)
Herbert Xu6a179442005-06-22 13:29:03 -070084{
Herbert Xu6a179442005-06-22 13:29:03 -070085 unsigned long cycles = 0;
86 int ret = 0;
87 int i;
88
Herbert Xu6a179442005-06-22 13:29:03 -070089 local_bh_disable();
90 local_irq_disable();
91
92 /* Warm-up run. */
93 for (i = 0; i < 4; i++) {
94 if (enc)
Herbert Xucba83562006-08-13 08:26:09 +100095 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -070096 else
Herbert Xucba83562006-08-13 08:26:09 +100097 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -070098
99 if (ret)
100 goto out;
101 }
102
103 /* The real thing. */
104 for (i = 0; i < 8; i++) {
105 cycles_t start, end;
106
107 start = get_cycles();
108 if (enc)
Herbert Xucba83562006-08-13 08:26:09 +1000109 ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700110 else
Herbert Xucba83562006-08-13 08:26:09 +1000111 ret = crypto_blkcipher_decrypt(desc, sg, sg, blen);
Herbert Xu6a179442005-06-22 13:29:03 -0700112 end = get_cycles();
113
114 if (ret)
115 goto out;
116
117 cycles += end - start;
118 }
119
120out:
121 local_irq_enable();
122 local_bh_enable();
123
124 if (ret == 0)
125 printk("1 operation in %lu cycles (%d bytes)\n",
126 (cycles + 4) / 8, blen);
127
128 return ret;
129}
130
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800131static u32 block_sizes[] = { 16, 64, 256, 1024, 8192, 0 };
132
Herbert Xu01b32322008-07-31 15:41:55 +0800133static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
Herbert Xuda7f0332008-07-31 17:08:25 +0800134 struct cipher_speed_template *template,
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800135 unsigned int tcount, u8 *keysize)
Harald Welteebfd9bc2005-06-22 13:27:23 -0700136{
Herbert Xudce907c2005-06-22 13:27:51 -0700137 unsigned int ret, i, j, iv_len;
Herbert Xuda7f0332008-07-31 17:08:25 +0800138 const char *key, iv[128];
Herbert Xucba83562006-08-13 08:26:09 +1000139 struct crypto_blkcipher *tfm;
140 struct blkcipher_desc desc;
141 const char *e;
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800142 u32 *b_size;
Harald Welteebfd9bc2005-06-22 13:27:23 -0700143
144 if (enc == ENCRYPT)
145 e = "encryption";
146 else
147 e = "decryption";
Harald Welteebfd9bc2005-06-22 13:27:23 -0700148
Herbert Xucba83562006-08-13 08:26:09 +1000149 printk("\ntesting speed of %s %s\n", algo, e);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700150
Herbert Xucba83562006-08-13 08:26:09 +1000151 tfm = crypto_alloc_blkcipher(algo, 0, CRYPTO_ALG_ASYNC);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700152
Herbert Xucba83562006-08-13 08:26:09 +1000153 if (IS_ERR(tfm)) {
154 printk("failed to load transform for %s: %ld\n", algo,
155 PTR_ERR(tfm));
Harald Welteebfd9bc2005-06-22 13:27:23 -0700156 return;
157 }
Herbert Xucba83562006-08-13 08:26:09 +1000158 desc.tfm = tfm;
159 desc.flags = 0;
Harald Welteebfd9bc2005-06-22 13:27:23 -0700160
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800161 i = 0;
162 do {
Harald Welteebfd9bc2005-06-22 13:27:23 -0700163
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800164 b_size = block_sizes;
165 do {
Herbert Xuf139cfa2008-07-31 12:23:53 +0800166 struct scatterlist sg[TVMEMSIZE];
Harald Welteebfd9bc2005-06-22 13:27:23 -0700167
Herbert Xuf139cfa2008-07-31 12:23:53 +0800168 if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
169 printk("template (%u) too big for "
170 "tvmem (%lu)\n", *keysize + *b_size,
171 TVMEMSIZE * PAGE_SIZE);
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800172 goto out;
173 }
Harald Welteebfd9bc2005-06-22 13:27:23 -0700174
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800175 printk("test %u (%d bit key, %d byte blocks): ", i,
176 *keysize * 8, *b_size);
177
Herbert Xuf139cfa2008-07-31 12:23:53 +0800178 memset(tvmem[0], 0xff, PAGE_SIZE);
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800179
180 /* set key, plain text and IV */
Herbert Xuda7f0332008-07-31 17:08:25 +0800181 key = tvmem[0];
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800182 for (j = 0; j < tcount; j++) {
183 if (template[j].klen == *keysize) {
184 key = template[j].key;
185 break;
186 }
187 }
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800188
189 ret = crypto_blkcipher_setkey(tfm, key, *keysize);
190 if (ret) {
191 printk("setkey() failed flags=%x\n",
192 crypto_blkcipher_get_flags(tfm));
193 goto out;
194 }
195
Herbert Xuf139cfa2008-07-31 12:23:53 +0800196 sg_init_table(sg, TVMEMSIZE);
197 sg_set_buf(sg, tvmem[0] + *keysize,
198 PAGE_SIZE - *keysize);
199 for (j = 1; j < TVMEMSIZE; j++) {
200 sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
201 memset (tvmem[j], 0xff, PAGE_SIZE);
202 }
203
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800204 iv_len = crypto_blkcipher_ivsize(tfm);
205 if (iv_len) {
206 memset(&iv, 0xff, iv_len);
207 crypto_blkcipher_set_iv(tfm, iv, iv_len);
208 }
209
210 if (sec)
Herbert Xuf139cfa2008-07-31 12:23:53 +0800211 ret = test_cipher_jiffies(&desc, enc, sg,
212 *b_size, sec);
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800213 else
Herbert Xuf139cfa2008-07-31 12:23:53 +0800214 ret = test_cipher_cycles(&desc, enc, sg,
215 *b_size);
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800216
217 if (ret) {
218 printk("%s() failed flags=%x\n", e, desc.flags);
Herbert Xudce907c2005-06-22 13:27:51 -0700219 break;
220 }
Sebastian Siewiord5dc3922008-03-11 21:27:11 +0800221 b_size++;
222 i++;
223 } while (*b_size);
224 keysize++;
225 } while (*keysize);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700226
227out:
Herbert Xucba83562006-08-13 08:26:09 +1000228 crypto_free_blkcipher(tfm);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700229}
230
Herbert Xuf139cfa2008-07-31 12:23:53 +0800231static int test_hash_jiffies_digest(struct hash_desc *desc,
232 struct scatterlist *sg, int blen,
Herbert Xue9d41162006-08-19 21:38:49 +1000233 char *out, int sec)
Michal Ludvige8057922006-05-30 22:04:19 +1000234{
Michal Ludvige8057922006-05-30 22:04:19 +1000235 unsigned long start, end;
Herbert Xue9d41162006-08-19 21:38:49 +1000236 int bcount;
237 int ret;
Michal Ludvige8057922006-05-30 22:04:19 +1000238
239 for (start = jiffies, end = start + sec * HZ, bcount = 0;
240 time_before(jiffies, end); bcount++) {
Herbert Xue9d41162006-08-19 21:38:49 +1000241 ret = crypto_hash_digest(desc, sg, blen, out);
242 if (ret)
243 return ret;
Michal Ludvige8057922006-05-30 22:04:19 +1000244 }
245
246 printk("%6u opers/sec, %9lu bytes/sec\n",
247 bcount / sec, ((long)bcount * blen) / sec);
248
Herbert Xue9d41162006-08-19 21:38:49 +1000249 return 0;
Michal Ludvige8057922006-05-30 22:04:19 +1000250}
251
Herbert Xuf139cfa2008-07-31 12:23:53 +0800252static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
253 int blen, int plen, char *out, int sec)
Herbert Xue9d41162006-08-19 21:38:49 +1000254{
Herbert Xue9d41162006-08-19 21:38:49 +1000255 unsigned long start, end;
256 int bcount, pcount;
257 int ret;
258
259 if (plen == blen)
Herbert Xuf139cfa2008-07-31 12:23:53 +0800260 return test_hash_jiffies_digest(desc, sg, blen, out, sec);
Herbert Xua5a613a2007-10-27 00:51:21 -0700261
Herbert Xue9d41162006-08-19 21:38:49 +1000262 for (start = jiffies, end = start + sec * HZ, bcount = 0;
263 time_before(jiffies, end); bcount++) {
264 ret = crypto_hash_init(desc);
265 if (ret)
266 return ret;
267 for (pcount = 0; pcount < blen; pcount += plen) {
Herbert Xue9d41162006-08-19 21:38:49 +1000268 ret = crypto_hash_update(desc, sg, plen);
269 if (ret)
270 return ret;
271 }
272 /* we assume there is enough space in 'out' for the result */
273 ret = crypto_hash_final(desc, out);
274 if (ret)
275 return ret;
276 }
277
278 printk("%6u opers/sec, %9lu bytes/sec\n",
279 bcount / sec, ((long)bcount * blen) / sec);
280
281 return 0;
282}
283
Herbert Xuf139cfa2008-07-31 12:23:53 +0800284static int test_hash_cycles_digest(struct hash_desc *desc,
285 struct scatterlist *sg, int blen, char *out)
Michal Ludvige8057922006-05-30 22:04:19 +1000286{
Michal Ludvige8057922006-05-30 22:04:19 +1000287 unsigned long cycles = 0;
Herbert Xue9d41162006-08-19 21:38:49 +1000288 int i;
289 int ret;
Michal Ludvige8057922006-05-30 22:04:19 +1000290
291 local_bh_disable();
292 local_irq_disable();
293
294 /* Warm-up run. */
295 for (i = 0; i < 4; i++) {
Herbert Xue9d41162006-08-19 21:38:49 +1000296 ret = crypto_hash_digest(desc, sg, blen, out);
297 if (ret)
298 goto out;
Michal Ludvige8057922006-05-30 22:04:19 +1000299 }
300
301 /* The real thing. */
302 for (i = 0; i < 8; i++) {
303 cycles_t start, end;
304
Michal Ludvige8057922006-05-30 22:04:19 +1000305 start = get_cycles();
306
Herbert Xue9d41162006-08-19 21:38:49 +1000307 ret = crypto_hash_digest(desc, sg, blen, out);
308 if (ret)
309 goto out;
Michal Ludvige8057922006-05-30 22:04:19 +1000310
311 end = get_cycles();
312
313 cycles += end - start;
314 }
315
Herbert Xue9d41162006-08-19 21:38:49 +1000316out:
Michal Ludvige8057922006-05-30 22:04:19 +1000317 local_irq_enable();
318 local_bh_enable();
319
Herbert Xue9d41162006-08-19 21:38:49 +1000320 if (ret)
321 return ret;
322
Michal Ludvige8057922006-05-30 22:04:19 +1000323 printk("%6lu cycles/operation, %4lu cycles/byte\n",
324 cycles / 8, cycles / (8 * blen));
325
Herbert Xue9d41162006-08-19 21:38:49 +1000326 return 0;
Michal Ludvige8057922006-05-30 22:04:19 +1000327}
328
Herbert Xuf139cfa2008-07-31 12:23:53 +0800329static int test_hash_cycles(struct hash_desc *desc, struct scatterlist *sg,
330 int blen, int plen, char *out)
Michal Ludvige8057922006-05-30 22:04:19 +1000331{
Herbert Xue9d41162006-08-19 21:38:49 +1000332 unsigned long cycles = 0;
333 int i, pcount;
334 int ret;
335
336 if (plen == blen)
Herbert Xuf139cfa2008-07-31 12:23:53 +0800337 return test_hash_cycles_digest(desc, sg, blen, out);
Herbert Xua5a613a2007-10-27 00:51:21 -0700338
Herbert Xue9d41162006-08-19 21:38:49 +1000339 local_bh_disable();
340 local_irq_disable();
341
342 /* Warm-up run. */
343 for (i = 0; i < 4; i++) {
344 ret = crypto_hash_init(desc);
345 if (ret)
346 goto out;
347 for (pcount = 0; pcount < blen; pcount += plen) {
Herbert Xue9d41162006-08-19 21:38:49 +1000348 ret = crypto_hash_update(desc, sg, plen);
349 if (ret)
350 goto out;
351 }
Herbert Xu29059d12007-05-18 16:25:19 +1000352 ret = crypto_hash_final(desc, out);
Herbert Xue9d41162006-08-19 21:38:49 +1000353 if (ret)
354 goto out;
355 }
356
357 /* The real thing. */
358 for (i = 0; i < 8; i++) {
359 cycles_t start, end;
360
361 start = get_cycles();
362
363 ret = crypto_hash_init(desc);
364 if (ret)
365 goto out;
366 for (pcount = 0; pcount < blen; pcount += plen) {
Herbert Xue9d41162006-08-19 21:38:49 +1000367 ret = crypto_hash_update(desc, sg, plen);
368 if (ret)
369 goto out;
370 }
371 ret = crypto_hash_final(desc, out);
372 if (ret)
373 goto out;
374
375 end = get_cycles();
376
377 cycles += end - start;
378 }
379
380out:
381 local_irq_enable();
382 local_bh_enable();
383
384 if (ret)
385 return ret;
386
387 printk("%6lu cycles/operation, %4lu cycles/byte\n",
388 cycles / 8, cycles / (8 * blen));
389
390 return 0;
391}
392
Herbert Xu01b32322008-07-31 15:41:55 +0800393static void test_hash_speed(const char *algo, unsigned int sec,
394 struct hash_speed *speed)
Herbert Xue9d41162006-08-19 21:38:49 +1000395{
Herbert Xuf139cfa2008-07-31 12:23:53 +0800396 struct scatterlist sg[TVMEMSIZE];
Herbert Xue9d41162006-08-19 21:38:49 +1000397 struct crypto_hash *tfm;
398 struct hash_desc desc;
Michal Ludvige8057922006-05-30 22:04:19 +1000399 char output[1024];
400 int i;
Herbert Xue9d41162006-08-19 21:38:49 +1000401 int ret;
Michal Ludvige8057922006-05-30 22:04:19 +1000402
403 printk("\ntesting speed of %s\n", algo);
404
Herbert Xue9d41162006-08-19 21:38:49 +1000405 tfm = crypto_alloc_hash(algo, 0, CRYPTO_ALG_ASYNC);
Michal Ludvige8057922006-05-30 22:04:19 +1000406
Herbert Xue9d41162006-08-19 21:38:49 +1000407 if (IS_ERR(tfm)) {
408 printk("failed to load transform for %s: %ld\n", algo,
409 PTR_ERR(tfm));
Michal Ludvige8057922006-05-30 22:04:19 +1000410 return;
411 }
412
Herbert Xue9d41162006-08-19 21:38:49 +1000413 desc.tfm = tfm;
414 desc.flags = 0;
415
416 if (crypto_hash_digestsize(tfm) > sizeof(output)) {
Michal Ludvige8057922006-05-30 22:04:19 +1000417 printk("digestsize(%u) > outputbuffer(%zu)\n",
Herbert Xue9d41162006-08-19 21:38:49 +1000418 crypto_hash_digestsize(tfm), sizeof(output));
Michal Ludvige8057922006-05-30 22:04:19 +1000419 goto out;
420 }
421
Herbert Xuf139cfa2008-07-31 12:23:53 +0800422 sg_init_table(sg, TVMEMSIZE);
423 for (i = 0; i < TVMEMSIZE; i++) {
424 sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
425 memset(tvmem[i], 0xff, PAGE_SIZE);
426 }
427
Michal Ludvige8057922006-05-30 22:04:19 +1000428 for (i = 0; speed[i].blen != 0; i++) {
Herbert Xuf139cfa2008-07-31 12:23:53 +0800429 if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
430 printk("template (%u) too big for tvmem (%lu)\n",
431 speed[i].blen, TVMEMSIZE * PAGE_SIZE);
Michal Ludvige8057922006-05-30 22:04:19 +1000432 goto out;
433 }
434
435 printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ",
436 i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
437
Michal Ludvige8057922006-05-30 22:04:19 +1000438 if (sec)
Herbert Xuf139cfa2008-07-31 12:23:53 +0800439 ret = test_hash_jiffies(&desc, sg, speed[i].blen,
Herbert Xue9d41162006-08-19 21:38:49 +1000440 speed[i].plen, output, sec);
Michal Ludvige8057922006-05-30 22:04:19 +1000441 else
Herbert Xuf139cfa2008-07-31 12:23:53 +0800442 ret = test_hash_cycles(&desc, sg, speed[i].blen,
Herbert Xue9d41162006-08-19 21:38:49 +1000443 speed[i].plen, output);
444
445 if (ret) {
446 printk("hashing failed ret=%d\n", ret);
447 break;
448 }
Michal Ludvige8057922006-05-30 22:04:19 +1000449 }
450
451out:
Herbert Xue9d41162006-08-19 21:38:49 +1000452 crypto_free_hash(tfm);
Michal Ludvige8057922006-05-30 22:04:19 +1000453}
454
Herbert Xuef2736f2005-06-22 13:26:03 -0700455static void test_available(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456{
457 char **name = check;
Herbert Xuef2736f2005-06-22 13:26:03 -0700458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 while (*name) {
460 printk("alg %s ", *name);
Herbert Xu6158efc2007-04-04 17:41:07 +1000461 printk(crypto_has_alg(*name, 0, 0) ?
Herbert Xue4d5b792006-08-26 18:12:40 +1000462 "found\n" : "not found\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 name++;
Herbert Xuef2736f2005-06-22 13:26:03 -0700464 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465}
466
Herbert Xu01b32322008-07-31 15:41:55 +0800467static inline int tcrypt_test(const char *alg)
468{
469 return alg_test(alg, alg, 0, 0);
470}
471
472static void do_test(int m)
473{
474 int i;
475
476 switch (m) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 case 0:
Herbert Xu01b32322008-07-31 15:41:55 +0800478 for (i = 1; i < 200; i++)
479 do_test(i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 break;
481
482 case 1:
Herbert Xu01b32322008-07-31 15:41:55 +0800483 tcrypt_test("md5");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 break;
485
486 case 2:
Herbert Xu01b32322008-07-31 15:41:55 +0800487 tcrypt_test("sha1");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 break;
489
490 case 3:
Herbert Xu01b32322008-07-31 15:41:55 +0800491 tcrypt_test("ecb(des)");
492 tcrypt_test("cbc(des)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 break;
494
495 case 4:
Herbert Xu01b32322008-07-31 15:41:55 +0800496 tcrypt_test("ecb(des3_ede)");
497 tcrypt_test("cbc(des3_ede)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 break;
499
500 case 5:
Herbert Xu01b32322008-07-31 15:41:55 +0800501 tcrypt_test("md4");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 break;
Herbert Xuef2736f2005-06-22 13:26:03 -0700503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 case 6:
Herbert Xu01b32322008-07-31 15:41:55 +0800505 tcrypt_test("sha256");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 break;
Herbert Xuef2736f2005-06-22 13:26:03 -0700507
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 case 7:
Herbert Xu01b32322008-07-31 15:41:55 +0800509 tcrypt_test("ecb(blowfish)");
510 tcrypt_test("cbc(blowfish)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 break;
512
513 case 8:
Herbert Xu01b32322008-07-31 15:41:55 +0800514 tcrypt_test("ecb(twofish)");
515 tcrypt_test("cbc(twofish)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 break;
Herbert Xuef2736f2005-06-22 13:26:03 -0700517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 case 9:
Herbert Xu01b32322008-07-31 15:41:55 +0800519 tcrypt_test("ecb(serpent)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 break;
521
522 case 10:
Herbert Xu01b32322008-07-31 15:41:55 +0800523 tcrypt_test("ecb(aes)");
524 tcrypt_test("cbc(aes)");
525 tcrypt_test("lrw(aes)");
526 tcrypt_test("xts(aes)");
527 tcrypt_test("rfc3686(ctr(aes))");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 break;
529
530 case 11:
Herbert Xu01b32322008-07-31 15:41:55 +0800531 tcrypt_test("sha384");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 break;
Herbert Xuef2736f2005-06-22 13:26:03 -0700533
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 case 12:
Herbert Xu01b32322008-07-31 15:41:55 +0800535 tcrypt_test("sha512");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 break;
537
538 case 13:
Herbert Xu01b32322008-07-31 15:41:55 +0800539 tcrypt_test("deflate");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 break;
541
542 case 14:
Herbert Xu01b32322008-07-31 15:41:55 +0800543 tcrypt_test("ecb(cast5)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 break;
545
546 case 15:
Herbert Xu01b32322008-07-31 15:41:55 +0800547 tcrypt_test("ecb(cast6)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 break;
549
550 case 16:
Herbert Xu01b32322008-07-31 15:41:55 +0800551 tcrypt_test("ecb(arc4)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 break;
553
554 case 17:
Herbert Xu01b32322008-07-31 15:41:55 +0800555 tcrypt_test("michael_mic");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 break;
557
558 case 18:
Herbert Xu01b32322008-07-31 15:41:55 +0800559 tcrypt_test("crc32c");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 break;
561
562 case 19:
Herbert Xu01b32322008-07-31 15:41:55 +0800563 tcrypt_test("ecb(tea)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 break;
565
566 case 20:
Herbert Xu01b32322008-07-31 15:41:55 +0800567 tcrypt_test("ecb(xtea)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 break;
569
570 case 21:
Herbert Xu01b32322008-07-31 15:41:55 +0800571 tcrypt_test("ecb(khazad)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 break;
573
574 case 22:
Herbert Xu01b32322008-07-31 15:41:55 +0800575 tcrypt_test("wp512");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 break;
577
578 case 23:
Herbert Xu01b32322008-07-31 15:41:55 +0800579 tcrypt_test("wp384");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 break;
581
582 case 24:
Herbert Xu01b32322008-07-31 15:41:55 +0800583 tcrypt_test("wp256");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 break;
585
586 case 25:
Herbert Xu01b32322008-07-31 15:41:55 +0800587 tcrypt_test("ecb(tnepres)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 break;
589
590 case 26:
Herbert Xu01b32322008-07-31 15:41:55 +0800591 tcrypt_test("ecb(anubis)");
592 tcrypt_test("cbc(anubis)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 break;
594
595 case 27:
Herbert Xu01b32322008-07-31 15:41:55 +0800596 tcrypt_test("tgr192");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 break;
598
599 case 28:
600
Herbert Xu01b32322008-07-31 15:41:55 +0800601 tcrypt_test("tgr160");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 break;
603
604 case 29:
Herbert Xu01b32322008-07-31 15:41:55 +0800605 tcrypt_test("tgr128");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 break;
Adrian-Ken Rueegsegger2998db32008-05-09 21:29:35 +0800607
Aaron Grothefb4f10e2005-09-01 17:42:46 -0700608 case 30:
Herbert Xu01b32322008-07-31 15:41:55 +0800609 tcrypt_test("ecb(xeta)");
Aaron Grothefb4f10e2005-09-01 17:42:46 -0700610 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
David Howells90831632006-12-16 12:13:14 +1100612 case 31:
Herbert Xu01b32322008-07-31 15:41:55 +0800613 tcrypt_test("pcbc(fcrypt)");
David Howells90831632006-12-16 12:13:14 +1100614 break;
615
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +1100616 case 32:
Herbert Xu01b32322008-07-31 15:41:55 +0800617 tcrypt_test("ecb(camellia)");
618 tcrypt_test("cbc(camellia)");
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +1100619 break;
Jonathan Lynchcd12fb92007-11-10 20:08:25 +0800620 case 33:
Herbert Xu01b32322008-07-31 15:41:55 +0800621 tcrypt_test("sha224");
Jonathan Lynchcd12fb92007-11-10 20:08:25 +0800622 break;
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +1100623
Tan Swee Heng2407d602007-11-23 19:45:00 +0800624 case 34:
Herbert Xu01b32322008-07-31 15:41:55 +0800625 tcrypt_test("salsa20");
Tan Swee Heng2407d602007-11-23 19:45:00 +0800626 break;
627
Herbert Xu8df213d2007-12-02 14:55:47 +1100628 case 35:
Herbert Xu01b32322008-07-31 15:41:55 +0800629 tcrypt_test("gcm(aes)");
Herbert Xu8df213d2007-12-02 14:55:47 +1100630 break;
631
Zoltan Sogor0b77abb2007-12-07 16:53:23 +0800632 case 36:
Herbert Xu01b32322008-07-31 15:41:55 +0800633 tcrypt_test("lzo");
Zoltan Sogor0b77abb2007-12-07 16:53:23 +0800634 break;
635
Joy Latten93cc74e2007-12-12 20:24:22 +0800636 case 37:
Herbert Xu01b32322008-07-31 15:41:55 +0800637 tcrypt_test("ccm(aes)");
Joy Latten93cc74e2007-12-12 20:24:22 +0800638 break;
639
Kevin Coffman76cb9522008-03-24 21:26:16 +0800640 case 38:
Herbert Xu01b32322008-07-31 15:41:55 +0800641 tcrypt_test("cts(cbc(aes))");
Kevin Coffman76cb9522008-03-24 21:26:16 +0800642 break;
643
Adrian-Ken Rueegseggerfd4adf12008-05-07 22:16:36 +0800644 case 39:
Herbert Xu01b32322008-07-31 15:41:55 +0800645 tcrypt_test("rmd128");
Adrian-Ken Rueegseggerfd4adf12008-05-07 22:16:36 +0800646 break;
647
648 case 40:
Herbert Xu01b32322008-07-31 15:41:55 +0800649 tcrypt_test("rmd160");
Adrian-Ken Rueegseggerfd4adf12008-05-07 22:16:36 +0800650 break;
651
Adrian-Ken Rueegsegger2998db32008-05-09 21:29:35 +0800652 case 41:
Herbert Xu01b32322008-07-31 15:41:55 +0800653 tcrypt_test("rmd256");
Adrian-Ken Rueegsegger2998db32008-05-09 21:29:35 +0800654 break;
655
656 case 42:
Herbert Xu01b32322008-07-31 15:41:55 +0800657 tcrypt_test("rmd320");
658 break;
659
660 case 43:
661 tcrypt_test("ecb(seed)");
Adrian-Ken Rueegsegger2998db32008-05-09 21:29:35 +0800662 break;
663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 case 100:
Herbert Xu01b32322008-07-31 15:41:55 +0800665 tcrypt_test("hmac(md5)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 break;
Herbert Xuef2736f2005-06-22 13:26:03 -0700667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 case 101:
Herbert Xu01b32322008-07-31 15:41:55 +0800669 tcrypt_test("hmac(sha1)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 break;
Herbert Xuef2736f2005-06-22 13:26:03 -0700671
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 case 102:
Herbert Xu01b32322008-07-31 15:41:55 +0800673 tcrypt_test("hmac(sha256)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 break;
675
Andrew Donofrioa28091a2006-12-10 12:10:20 +1100676 case 103:
Herbert Xu01b32322008-07-31 15:41:55 +0800677 tcrypt_test("hmac(sha384)");
Andrew Donofrioa28091a2006-12-10 12:10:20 +1100678 break;
679
680 case 104:
Herbert Xu01b32322008-07-31 15:41:55 +0800681 tcrypt_test("hmac(sha512)");
Andrew Donofrioa28091a2006-12-10 12:10:20 +1100682 break;
Herbert Xu38ed9ab2008-01-01 15:59:28 +1100683
Jonathan Lynchcd12fb92007-11-10 20:08:25 +0800684 case 105:
Herbert Xu01b32322008-07-31 15:41:55 +0800685 tcrypt_test("hmac(sha224)");
Jonathan Lynchcd12fb92007-11-10 20:08:25 +0800686 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Herbert Xu38ed9ab2008-01-01 15:59:28 +1100688 case 106:
Herbert Xu01b32322008-07-31 15:41:55 +0800689 tcrypt_test("xcbc(aes)");
Herbert Xu38ed9ab2008-01-01 15:59:28 +1100690 break;
691
Adrian-Ken Rueegseggerfd4adf12008-05-07 22:16:36 +0800692 case 107:
Herbert Xu01b32322008-07-31 15:41:55 +0800693 tcrypt_test("hmac(rmd128)");
Adrian-Ken Rueegseggerfd4adf12008-05-07 22:16:36 +0800694 break;
695
696 case 108:
Herbert Xu01b32322008-07-31 15:41:55 +0800697 tcrypt_test("hmac(rmd160)");
Adrian-Ken Rueegseggerfd4adf12008-05-07 22:16:36 +0800698 break;
699
Harald Welteebfd9bc2005-06-22 13:27:23 -0700700 case 200:
Herbert Xucba83562006-08-13 08:26:09 +1000701 test_cipher_speed("ecb(aes)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800702 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +1000703 test_cipher_speed("ecb(aes)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800704 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +1000705 test_cipher_speed("cbc(aes)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800706 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +1000707 test_cipher_speed("cbc(aes)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800708 speed_template_16_24_32);
Rik Snelf3d10442006-11-29 19:01:41 +1100709 test_cipher_speed("lrw(aes)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800710 speed_template_32_40_48);
Rik Snelf3d10442006-11-29 19:01:41 +1100711 test_cipher_speed("lrw(aes)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800712 speed_template_32_40_48);
Rik Snelf19f5112007-09-19 20:23:13 +0800713 test_cipher_speed("xts(aes)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800714 speed_template_32_48_64);
Rik Snelf19f5112007-09-19 20:23:13 +0800715 test_cipher_speed("xts(aes)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800716 speed_template_32_48_64);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700717 break;
718
719 case 201:
Herbert Xucba83562006-08-13 08:26:09 +1000720 test_cipher_speed("ecb(des3_ede)", ENCRYPT, sec,
Herbert Xuda7f0332008-07-31 17:08:25 +0800721 des3_speed_template, DES3_SPEED_VECTORS,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800722 speed_template_24);
Herbert Xucba83562006-08-13 08:26:09 +1000723 test_cipher_speed("ecb(des3_ede)", DECRYPT, sec,
Herbert Xuda7f0332008-07-31 17:08:25 +0800724 des3_speed_template, DES3_SPEED_VECTORS,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800725 speed_template_24);
Herbert Xucba83562006-08-13 08:26:09 +1000726 test_cipher_speed("cbc(des3_ede)", ENCRYPT, sec,
Herbert Xuda7f0332008-07-31 17:08:25 +0800727 des3_speed_template, DES3_SPEED_VECTORS,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800728 speed_template_24);
Herbert Xucba83562006-08-13 08:26:09 +1000729 test_cipher_speed("cbc(des3_ede)", DECRYPT, sec,
Herbert Xuda7f0332008-07-31 17:08:25 +0800730 des3_speed_template, DES3_SPEED_VECTORS,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800731 speed_template_24);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700732 break;
733
734 case 202:
Herbert Xucba83562006-08-13 08:26:09 +1000735 test_cipher_speed("ecb(twofish)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800736 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +1000737 test_cipher_speed("ecb(twofish)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800738 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +1000739 test_cipher_speed("cbc(twofish)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800740 speed_template_16_24_32);
Herbert Xucba83562006-08-13 08:26:09 +1000741 test_cipher_speed("cbc(twofish)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800742 speed_template_16_24_32);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700743 break;
744
745 case 203:
Herbert Xucba83562006-08-13 08:26:09 +1000746 test_cipher_speed("ecb(blowfish)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800747 speed_template_8_32);
Herbert Xucba83562006-08-13 08:26:09 +1000748 test_cipher_speed("ecb(blowfish)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800749 speed_template_8_32);
Herbert Xucba83562006-08-13 08:26:09 +1000750 test_cipher_speed("cbc(blowfish)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800751 speed_template_8_32);
Herbert Xucba83562006-08-13 08:26:09 +1000752 test_cipher_speed("cbc(blowfish)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800753 speed_template_8_32);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700754 break;
755
756 case 204:
Herbert Xucba83562006-08-13 08:26:09 +1000757 test_cipher_speed("ecb(des)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800758 speed_template_8);
Herbert Xucba83562006-08-13 08:26:09 +1000759 test_cipher_speed("ecb(des)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800760 speed_template_8);
Herbert Xucba83562006-08-13 08:26:09 +1000761 test_cipher_speed("cbc(des)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800762 speed_template_8);
Herbert Xucba83562006-08-13 08:26:09 +1000763 test_cipher_speed("cbc(des)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800764 speed_template_8);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700765 break;
766
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +1100767 case 205:
768 test_cipher_speed("ecb(camellia)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800769 speed_template_16_24_32);
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +1100770 test_cipher_speed("ecb(camellia)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800771 speed_template_16_24_32);
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +1100772 test_cipher_speed("cbc(camellia)", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800773 speed_template_16_24_32);
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +1100774 test_cipher_speed("cbc(camellia)", DECRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800775 speed_template_16_24_32);
Noriaki TAKAMIYA02ab5a72007-01-24 21:48:19 +1100776 break;
777
Tan Swee Heng5de8f1b2007-12-07 17:17:43 +0800778 case 206:
779 test_cipher_speed("salsa20", ENCRYPT, sec, NULL, 0,
Sebastian Siewior477035c2008-03-11 21:24:26 +0800780 speed_template_16_32);
Tan Swee Heng5de8f1b2007-12-07 17:17:43 +0800781 break;
782
Michal Ludvige8057922006-05-30 22:04:19 +1000783 case 300:
784 /* fall through */
785
786 case 301:
Herbert Xue9d41162006-08-19 21:38:49 +1000787 test_hash_speed("md4", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000788 if (mode > 300 && mode < 400) break;
789
790 case 302:
Herbert Xue9d41162006-08-19 21:38:49 +1000791 test_hash_speed("md5", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000792 if (mode > 300 && mode < 400) break;
793
794 case 303:
Herbert Xue9d41162006-08-19 21:38:49 +1000795 test_hash_speed("sha1", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000796 if (mode > 300 && mode < 400) break;
797
798 case 304:
Herbert Xue9d41162006-08-19 21:38:49 +1000799 test_hash_speed("sha256", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000800 if (mode > 300 && mode < 400) break;
801
802 case 305:
Herbert Xue9d41162006-08-19 21:38:49 +1000803 test_hash_speed("sha384", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000804 if (mode > 300 && mode < 400) break;
805
806 case 306:
Herbert Xue9d41162006-08-19 21:38:49 +1000807 test_hash_speed("sha512", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000808 if (mode > 300 && mode < 400) break;
809
810 case 307:
Herbert Xue9d41162006-08-19 21:38:49 +1000811 test_hash_speed("wp256", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000812 if (mode > 300 && mode < 400) break;
813
814 case 308:
Herbert Xue9d41162006-08-19 21:38:49 +1000815 test_hash_speed("wp384", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000816 if (mode > 300 && mode < 400) break;
817
818 case 309:
Herbert Xue9d41162006-08-19 21:38:49 +1000819 test_hash_speed("wp512", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000820 if (mode > 300 && mode < 400) break;
821
822 case 310:
Herbert Xue9d41162006-08-19 21:38:49 +1000823 test_hash_speed("tgr128", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000824 if (mode > 300 && mode < 400) break;
825
826 case 311:
Herbert Xue9d41162006-08-19 21:38:49 +1000827 test_hash_speed("tgr160", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000828 if (mode > 300 && mode < 400) break;
829
830 case 312:
Herbert Xue9d41162006-08-19 21:38:49 +1000831 test_hash_speed("tgr192", sec, generic_hash_speed_template);
Michal Ludvige8057922006-05-30 22:04:19 +1000832 if (mode > 300 && mode < 400) break;
833
Jonathan Lynchcd12fb92007-11-10 20:08:25 +0800834 case 313:
835 test_hash_speed("sha224", sec, generic_hash_speed_template);
836 if (mode > 300 && mode < 400) break;
837
Adrian-Ken Rueegseggerfd4adf12008-05-07 22:16:36 +0800838 case 314:
839 test_hash_speed("rmd128", sec, generic_hash_speed_template);
840 if (mode > 300 && mode < 400) break;
841
842 case 315:
843 test_hash_speed("rmd160", sec, generic_hash_speed_template);
844 if (mode > 300 && mode < 400) break;
845
Adrian-Ken Rueegsegger2998db32008-05-09 21:29:35 +0800846 case 316:
847 test_hash_speed("rmd256", sec, generic_hash_speed_template);
848 if (mode > 300 && mode < 400) break;
849
850 case 317:
851 test_hash_speed("rmd320", sec, generic_hash_speed_template);
852 if (mode > 300 && mode < 400) break;
853
Michal Ludvige8057922006-05-30 22:04:19 +1000854 case 399:
855 break;
856
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 case 1000:
858 test_available();
859 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 }
861}
862
Kamalesh Babulal3af5b902008-04-05 21:00:57 +0800863static int __init tcrypt_mod_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864{
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800865 int err = -ENOMEM;
Herbert Xuf139cfa2008-07-31 12:23:53 +0800866 int i;
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800867
Herbert Xuf139cfa2008-07-31 12:23:53 +0800868 for (i = 0; i < TVMEMSIZE; i++) {
869 tvmem[i] = (void *)__get_free_page(GFP_KERNEL);
870 if (!tvmem[i])
871 goto err_free_tv;
872 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Herbert Xu01b32322008-07-31 15:41:55 +0800874 do_test(mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
Michal Ludvig14fdf472006-05-30 14:49:38 +1000876 /* We intentionaly return -EAGAIN to prevent keeping
877 * the module. It does all its work from init()
878 * and doesn't offer any runtime functionality
879 * => we don't need it in the memory, do we?
880 * -- mludvig
881 */
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800882 err = -EAGAIN;
883
Herbert Xuf139cfa2008-07-31 12:23:53 +0800884err_free_tv:
885 for (i = 0; i < TVMEMSIZE && tvmem[i]; i++)
886 free_page((unsigned long)tvmem[i]);
Mikko Herranene3a4ea42007-11-26 22:12:07 +0800887
888 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889}
890
891/*
892 * If an init function is provided, an exit function must also be provided
893 * to allow module unload.
894 */
Kamalesh Babulal3af5b902008-04-05 21:00:57 +0800895static void __exit tcrypt_mod_fini(void) { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Kamalesh Babulal3af5b902008-04-05 21:00:57 +0800897module_init(tcrypt_mod_init);
898module_exit(tcrypt_mod_fini);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
900module_param(mode, int, 0);
Harald Welteebfd9bc2005-06-22 13:27:23 -0700901module_param(sec, uint, 0);
Herbert Xu6a179442005-06-22 13:29:03 -0700902MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
903 "(defaults to zero which uses CPU cycles instead)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
905MODULE_LICENSE("GPL");
906MODULE_DESCRIPTION("Quick & dirty crypto testing module");
907MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");