a9a953818fa100135704578b1eeb643a2f27a605
[15.05/openwrt.git] / target / linux / generic / files / crypto / ocf / ocf-bench.c
1 /*
2  * A loadable module that benchmarks the OCF crypto speed from kernel space.
3  *
4  * Copyright (C) 2004-2010 David McCullough <david_mccullough@mcafee.com>
5  *
6  * LICENSE TERMS
7  *
8  * The free distribution and use of this software in both source and binary
9  * form is allowed (with or without changes) provided that:
10  *
11  *   1. distributions of this source code include the above copyright
12  *      notice, this list of conditions and the following disclaimer;
13  *
14  *   2. distributions in binary form include the above copyright
15  *      notice, this list of conditions and the following disclaimer
16  *      in the documentation and/or other associated materials;
17  *
18  *   3. the copyright holder's name is not used to endorse products
19  *      built using this software without specific written permission.
20  *
21  * ALTERNATIVELY, provided that this notice is retained in full, this product
22  * may be distributed under the terms of the GNU General Public License (GPL),
23  * in which case the provisions of the GPL apply INSTEAD OF those given above.
24  *
25  * DISCLAIMER
26  *
27  * This software is provided 'as is' with no explicit or implied warranties
28  * in respect of its properties, including, but not limited to, correctness
29  * and/or fitness for purpose.
30  */
31
32
33 #include <linux/version.h>
34 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38) && !defined(AUTOCONF_INCLUDED)
35 #include <linux/config.h>
36 #endif
37 #include <linux/module.h>
38 #include <linux/init.h>
39 #include <linux/list.h>
40 #include <linux/slab.h>
41 #include <linux/wait.h>
42 #include <linux/sched.h>
43 #include <linux/spinlock.h>
44 #include <linux/interrupt.h>
45 #include <cryptodev.h>
46
47 #ifdef I_HAVE_AN_XSCALE_WITH_INTEL_SDK
48 #define BENCH_IXP_ACCESS_LIB 1
49 #endif
50 #ifdef BENCH_IXP_ACCESS_LIB
51 #include <IxTypes.h>
52 #include <IxOsBuffMgt.h>
53 #include <IxNpeDl.h>
54 #include <IxCryptoAcc.h>
55 #include <IxQMgr.h>
56 #include <IxOsServices.h>
57 #include <IxOsCacheMMU.h>
58 #endif
59
60 /*
61  * support for access lib version 1.4
62  */
63 #ifndef IX_MBUF_PRIV
64 #define IX_MBUF_PRIV(x) ((x)->priv)
65 #endif
66
67 /*
68  * the number of simultaneously active requests
69  */
70 static int request_q_len = 40;
71 module_param(request_q_len, int, 0);
72 MODULE_PARM_DESC(request_q_len, "Number of outstanding requests");
73
74 /*
75  * how many requests we want to have processed
76  */
77 static int request_num = 1024;
78 module_param(request_num, int, 0);
79 MODULE_PARM_DESC(request_num, "run for at least this many requests");
80
81 /*
82  * the size of each request
83  */
84 static int request_size = 1488;
85 module_param(request_size, int, 0);
86 MODULE_PARM_DESC(request_size, "size of each request");
87
88 /*
89  * OCF batching of requests
90  */
91 static int request_batch = 1;
92 module_param(request_batch, int, 0);
93 MODULE_PARM_DESC(request_batch, "enable OCF request batching");
94
95 /*
96  * OCF immediate callback on completion
97  */
98 static int request_cbimm = 1;
99 module_param(request_cbimm, int, 0);
100 MODULE_PARM_DESC(request_cbimm, "enable OCF immediate callback on completion");
101
102 /*
103  * a structure for each request
104  */
105 typedef struct  {
106         struct work_struct work;
107 #ifdef BENCH_IXP_ACCESS_LIB
108         IX_MBUF mbuf;
109 #endif
110         unsigned char *buffer;
111 } request_t;
112
113 static request_t *requests;
114
115 static spinlock_t ocfbench_counter_lock;
116 static int outstanding;
117 static int total;
118
119 /*************************************************************************/
120 /*
121  * OCF benchmark routines
122  */
123
124 static uint64_t ocf_cryptoid;
125 static unsigned long jstart, jstop;
126
127 static int ocf_init(void);
128 static int ocf_cb(struct cryptop *crp);
129 static void ocf_request(void *arg);
130 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
131 static void ocf_request_wq(struct work_struct *work);
132 #endif
133
134 static int
135 ocf_init(void)
136 {
137         int error;
138         struct cryptoini crie, cria;
139         struct cryptodesc crda, crde;
140
141         memset(&crie, 0, sizeof(crie));
142         memset(&cria, 0, sizeof(cria));
143         memset(&crde, 0, sizeof(crde));
144         memset(&crda, 0, sizeof(crda));
145
146         cria.cri_alg  = CRYPTO_SHA1_HMAC;
147         cria.cri_klen = 20 * 8;
148         cria.cri_key  = "0123456789abcdefghij";
149
150         //crie.cri_alg  = CRYPTO_3DES_CBC;
151         crie.cri_alg  = CRYPTO_AES_CBC;
152         crie.cri_klen = 24 * 8;
153         crie.cri_key  = "0123456789abcdefghijklmn";
154
155         crie.cri_next = &cria;
156
157         error = crypto_newsession(&ocf_cryptoid, &crie,
158                                 CRYPTOCAP_F_HARDWARE | CRYPTOCAP_F_SOFTWARE);
159         if (error) {
160                 printk("crypto_newsession failed %d\n", error);
161                 return -1;
162         }
163         return 0;
164 }
165
166 static int
167 ocf_cb(struct cryptop *crp)
168 {
169         request_t *r = (request_t *) crp->crp_opaque;
170         unsigned long flags;
171
172         if (crp->crp_etype)
173                 printk("Error in OCF processing: %d\n", crp->crp_etype);
174         crypto_freereq(crp);
175         crp = NULL;
176
177         /* do all requests  but take at least 1 second */
178         spin_lock_irqsave(&ocfbench_counter_lock, flags);
179         total++;
180         if (total > request_num && jstart + HZ < jiffies) {
181                 outstanding--;
182                 spin_unlock_irqrestore(&ocfbench_counter_lock, flags);
183                 return 0;
184         }
185         spin_unlock_irqrestore(&ocfbench_counter_lock, flags);
186
187         schedule_work(&r->work);
188         return 0;
189 }
190
191
192 static void
193 ocf_request(void *arg)
194 {
195         request_t *r = arg;
196         struct cryptop *crp = crypto_getreq(2);
197         struct cryptodesc *crde, *crda;
198         unsigned long flags;
199
200         if (!crp) {
201                 spin_lock_irqsave(&ocfbench_counter_lock, flags);
202                 outstanding--;
203                 spin_unlock_irqrestore(&ocfbench_counter_lock, flags);
204                 return;
205         }
206
207         crde = crp->crp_desc;
208         crda = crde->crd_next;
209
210         crda->crd_skip = 0;
211         crda->crd_flags = 0;
212         crda->crd_len = request_size;
213         crda->crd_inject = request_size;
214         crda->crd_alg = CRYPTO_SHA1_HMAC;
215         crda->crd_key = "0123456789abcdefghij";
216         crda->crd_klen = 20 * 8;
217
218         crde->crd_skip = 0;
219         crde->crd_flags = CRD_F_IV_EXPLICIT | CRD_F_ENCRYPT;
220         crde->crd_len = request_size;
221         crde->crd_inject = request_size;
222         //crde->crd_alg = CRYPTO_3DES_CBC;
223         crde->crd_alg = CRYPTO_AES_CBC;
224         crde->crd_key = "0123456789abcdefghijklmn";
225         crde->crd_klen = 24 * 8;
226
227         crp->crp_ilen = request_size + 64;
228         crp->crp_flags = 0;
229         if (request_batch)
230                 crp->crp_flags |= CRYPTO_F_BATCH;
231         if (request_cbimm)
232                 crp->crp_flags |= CRYPTO_F_CBIMM;
233         crp->crp_buf = (caddr_t) r->buffer;
234         crp->crp_callback = ocf_cb;
235         crp->crp_sid = ocf_cryptoid;
236         crp->crp_opaque = (caddr_t) r;
237         crypto_dispatch(crp);
238 }
239
240 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
241 static void
242 ocf_request_wq(struct work_struct *work)
243 {
244         request_t *r = container_of(work, request_t, work);
245         ocf_request(r);
246 }
247 #endif
248
249 static void
250 ocf_done(void)
251 {
252         crypto_freesession(ocf_cryptoid);
253 }
254
255 /*************************************************************************/
256 #ifdef BENCH_IXP_ACCESS_LIB
257 /*************************************************************************/
258 /*
259  * CryptoAcc benchmark routines
260  */
261
262 static IxCryptoAccCtx ixp_ctx;
263 static UINT32 ixp_ctx_id;
264 static IX_MBUF ixp_pri;
265 static IX_MBUF ixp_sec;
266 static int ixp_registered = 0;
267
268 static void ixp_register_cb(UINT32 ctx_id, IX_MBUF *bufp,
269                                         IxCryptoAccStatus status);
270 static void ixp_perform_cb(UINT32 ctx_id, IX_MBUF *sbufp, IX_MBUF *dbufp,
271                                         IxCryptoAccStatus status);
272 static void ixp_request(void *arg);
273 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
274 static void ixp_request_wq(struct work_struct *work);
275 #endif
276
277 static int
278 ixp_init(void)
279 {
280         IxCryptoAccStatus status;
281
282         ixp_ctx.cipherCtx.cipherAlgo = IX_CRYPTO_ACC_CIPHER_3DES;
283         ixp_ctx.cipherCtx.cipherMode = IX_CRYPTO_ACC_MODE_CBC;
284         ixp_ctx.cipherCtx.cipherKeyLen = 24;
285         ixp_ctx.cipherCtx.cipherBlockLen = IX_CRYPTO_ACC_DES_BLOCK_64;
286         ixp_ctx.cipherCtx.cipherInitialVectorLen = IX_CRYPTO_ACC_DES_IV_64;
287         memcpy(ixp_ctx.cipherCtx.key.cipherKey, "0123456789abcdefghijklmn", 24);
288
289         ixp_ctx.authCtx.authAlgo = IX_CRYPTO_ACC_AUTH_SHA1;
290         ixp_ctx.authCtx.authDigestLen = 12;
291         ixp_ctx.authCtx.aadLen = 0;
292         ixp_ctx.authCtx.authKeyLen = 20;
293         memcpy(ixp_ctx.authCtx.key.authKey, "0123456789abcdefghij", 20);
294
295         ixp_ctx.useDifferentSrcAndDestMbufs = 0;
296         ixp_ctx.operation = IX_CRYPTO_ACC_OP_ENCRYPT_AUTH ;
297
298         IX_MBUF_MLEN(&ixp_pri)  = IX_MBUF_PKT_LEN(&ixp_pri) = 128;
299         IX_MBUF_MDATA(&ixp_pri) = (unsigned char *) kmalloc(128, SLAB_ATOMIC);
300         IX_MBUF_MLEN(&ixp_sec)  = IX_MBUF_PKT_LEN(&ixp_sec) = 128;
301         IX_MBUF_MDATA(&ixp_sec) = (unsigned char *) kmalloc(128, SLAB_ATOMIC);
302
303         status = ixCryptoAccCtxRegister(&ixp_ctx, &ixp_pri, &ixp_sec,
304                         ixp_register_cb, ixp_perform_cb, &ixp_ctx_id);
305
306         if (IX_CRYPTO_ACC_STATUS_SUCCESS == status) {
307                 while (!ixp_registered)
308                         schedule();
309                 return ixp_registered < 0 ? -1 : 0;
310         }
311
312         printk("ixp: ixCryptoAccCtxRegister failed %d\n", status);
313         return -1;
314 }
315
316 static void
317 ixp_register_cb(UINT32 ctx_id, IX_MBUF *bufp, IxCryptoAccStatus status)
318 {
319         if (bufp) {
320                 IX_MBUF_MLEN(bufp) = IX_MBUF_PKT_LEN(bufp) = 0;
321                 kfree(IX_MBUF_MDATA(bufp));
322                 IX_MBUF_MDATA(bufp) = NULL;
323         }
324
325         if (IX_CRYPTO_ACC_STATUS_WAIT == status)
326                 return;
327         if (IX_CRYPTO_ACC_STATUS_SUCCESS == status)
328                 ixp_registered = 1;
329         else
330                 ixp_registered = -1;
331 }
332
333 static void
334 ixp_perform_cb(
335         UINT32 ctx_id,
336         IX_MBUF *sbufp,
337         IX_MBUF *dbufp,
338         IxCryptoAccStatus status)
339 {
340         request_t *r = NULL;
341         unsigned long flags;
342
343         /* do all requests  but take at least 1 second */
344         spin_lock_irqsave(&ocfbench_counter_lock, flags);
345         total++;
346         if (total > request_num && jstart + HZ < jiffies) {
347                 outstanding--;
348                 spin_unlock_irqrestore(&ocfbench_counter_lock, flags);
349                 return;
350         }
351
352         if (!sbufp || !(r = IX_MBUF_PRIV(sbufp))) {
353                 printk("crappo %p %p\n", sbufp, r);
354                 outstanding--;
355                 spin_unlock_irqrestore(&ocfbench_counter_lock, flags);
356                 return;
357         }
358         spin_unlock_irqrestore(&ocfbench_counter_lock, flags);
359
360         schedule_work(&r->work);
361 }
362
363 static void
364 ixp_request(void *arg)
365 {
366         request_t *r = arg;
367         IxCryptoAccStatus status;
368         unsigned long flags;
369
370         memset(&r->mbuf, 0, sizeof(r->mbuf));
371         IX_MBUF_MLEN(&r->mbuf) = IX_MBUF_PKT_LEN(&r->mbuf) = request_size + 64;
372         IX_MBUF_MDATA(&r->mbuf) = r->buffer;
373         IX_MBUF_PRIV(&r->mbuf) = r;
374         status = ixCryptoAccAuthCryptPerform(ixp_ctx_id, &r->mbuf, NULL,
375                         0, request_size, 0, request_size, request_size, r->buffer);
376         if (IX_CRYPTO_ACC_STATUS_SUCCESS != status) {
377                 printk("status1 = %d\n", status);
378                 spin_lock_irqsave(&ocfbench_counter_lock, flags);
379                 outstanding--;
380                 spin_unlock_irqrestore(&ocfbench_counter_lock, flags);
381                 return;
382         }
383         return;
384 }
385
386 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
387 static void
388 ixp_request_wq(struct work_struct *work)
389 {
390         request_t *r = container_of(work, request_t, work);
391         ixp_request(r);
392 }
393 #endif
394
395 static void
396 ixp_done(void)
397 {
398         /* we should free the session here but I am lazy :-) */
399 }
400
401 /*************************************************************************/
402 #endif /* BENCH_IXP_ACCESS_LIB */
403 /*************************************************************************/
404
405 int
406 ocfbench_init(void)
407 {
408         int i;
409         unsigned long mbps;
410         unsigned long flags;
411
412         printk("Crypto Speed tests\n");
413
414         requests = kmalloc(sizeof(request_t) * request_q_len, GFP_KERNEL);
415         if (!requests) {
416                 printk("malloc failed\n");
417                 return -EINVAL;
418         }
419
420         for (i = 0; i < request_q_len; i++) {
421                 /* +64 for return data */
422 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
423                 INIT_WORK(&requests[i].work, ocf_request_wq);
424 #else
425                 INIT_WORK(&requests[i].work, ocf_request, &requests[i]);
426 #endif
427                 requests[i].buffer = kmalloc(request_size + 128, GFP_DMA);
428                 if (!requests[i].buffer) {
429                         printk("malloc failed\n");
430                         return -EINVAL;
431                 }
432                 memset(requests[i].buffer, '0' + i, request_size + 128);
433         }
434
435         /*
436          * OCF benchmark
437          */
438         printk("OCF: testing ...\n");
439         if (ocf_init() == -1)
440                 return -EINVAL;
441
442         spin_lock_init(&ocfbench_counter_lock);
443         total = outstanding = 0;
444         jstart = jiffies;
445         for (i = 0; i < request_q_len; i++) {
446                 spin_lock_irqsave(&ocfbench_counter_lock, flags);
447                 outstanding++;
448                 spin_unlock_irqrestore(&ocfbench_counter_lock, flags);
449                 ocf_request(&requests[i]);
450         }
451         while (outstanding > 0)
452                 schedule();
453         jstop = jiffies;
454
455         mbps = 0;
456         if (jstop > jstart) {
457                 mbps = (unsigned long) total * (unsigned long) request_size * 8;
458                 mbps /= ((jstop - jstart) * 1000) / HZ;
459         }
460         printk("OCF: %d requests of %d bytes in %d jiffies (%d.%03d Mbps)\n",
461                         total, request_size, (int)(jstop - jstart),
462                         ((int)mbps) / 1000, ((int)mbps) % 1000);
463         ocf_done();
464
465 #ifdef BENCH_IXP_ACCESS_LIB
466         /*
467          * IXP benchmark
468          */
469         printk("IXP: testing ...\n");
470         ixp_init();
471         total = outstanding = 0;
472         jstart = jiffies;
473         for (i = 0; i < request_q_len; i++) {
474 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
475                 INIT_WORK(&requests[i].work, ixp_request_wq);
476 #else
477                 INIT_WORK(&requests[i].work, ixp_request, &requests[i]);
478 #endif
479                 spin_lock_irqsave(&ocfbench_counter_lock, flags);
480                 outstanding++;
481                 spin_unlock_irqrestore(&ocfbench_counter_lock, flags);
482                 ixp_request(&requests[i]);
483         }
484         while (outstanding > 0)
485                 schedule();
486         jstop = jiffies;
487
488         mbps = 0;
489         if (jstop > jstart) {
490                 mbps = (unsigned long) total * (unsigned long) request_size * 8;
491                 mbps /= ((jstop - jstart) * 1000) / HZ;
492         }
493         printk("IXP: %d requests of %d bytes in %d jiffies (%d.%03d Mbps)\n",
494                         total, request_size, jstop - jstart,
495                         ((int)mbps) / 1000, ((int)mbps) % 1000);
496         ixp_done();
497 #endif /* BENCH_IXP_ACCESS_LIB */
498
499         for (i = 0; i < request_q_len; i++)
500                 kfree(requests[i].buffer);
501         kfree(requests);
502         return -EINVAL; /* always fail to load so it can be re-run quickly ;-) */
503 }
504
505 static void __exit ocfbench_exit(void)
506 {
507 }
508
509 module_init(ocfbench_init);
510 module_exit(ocfbench_exit);
511
512 MODULE_LICENSE("Dual BSD/GPL");
513 MODULE_AUTHOR("David McCullough <david_mccullough@mcafee.com>");
514 MODULE_DESCRIPTION("Benchmark various in-kernel crypto speeds");