Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Shared crypto simd helpers
4 *
5 * Copyright (c) 2012 Jussi Kivilinna <jussi.kivilinna@mbnet.fi>
6 * Copyright (c) 2016 Herbert Xu <herbert@gondor.apana.org.au>
7 * Copyright (c) 2019 Google LLC
8 *
9 * Based on aesni-intel_glue.c by:
10 * Copyright (C) 2008, Intel Corp.
11 * Author: Huang Ying <ying.huang@intel.com>
12 */
13
14/*
15 * Shared crypto SIMD helpers. These functions dynamically create and register
16 * an skcipher or AEAD algorithm that wraps another, internal algorithm. The
17 * wrapper ensures that the internal algorithm is only executed in a context
18 * where SIMD instructions are usable, i.e. where may_use_simd() returns true.
19 * If SIMD is already usable, the wrapper directly calls the internal algorithm.
20 * Otherwise it defers execution to a workqueue via cryptd.
21 *
22 * This is an alternative to the internal algorithm implementing a fallback for
23 * the !may_use_simd() case itself.
24 *
25 * Note that the wrapper algorithm is asynchronous, i.e. it has the
26 * CRYPTO_ALG_ASYNC flag set. Therefore it won't be found by users who
27 * explicitly allocate a synchronous algorithm.
28 */
29
30#include <crypto/cryptd.h>
31#include <crypto/internal/aead.h>
32#include <crypto/internal/simd.h>
33#include <crypto/internal/skcipher.h>
34#include <linux/kernel.h>
35#include <linux/module.h>
36#include <linux/preempt.h>
37#include <asm/simd.h>
38
39/* skcipher support */
40
41struct simd_skcipher_alg {
42 const char *ialg_name;
43 struct skcipher_alg alg;
44};
45
46struct simd_skcipher_ctx {
47 struct cryptd_skcipher *cryptd_tfm;
48};
49
50static int simd_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key,
51 unsigned int key_len)
52{
53 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
54 struct crypto_skcipher *child = &ctx->cryptd_tfm->base;
55 int err;
56
57 crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
58 crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(tfm) &
59 CRYPTO_TFM_REQ_MASK);
60 err = crypto_skcipher_setkey(child, key, key_len);
61 crypto_skcipher_set_flags(tfm, crypto_skcipher_get_flags(child) &
62 CRYPTO_TFM_RES_MASK);
63 return err;
64}
65
66static int simd_skcipher_encrypt(struct skcipher_request *req)
67{
68 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
69 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
70 struct skcipher_request *subreq;
71 struct crypto_skcipher *child;
72
73 subreq = skcipher_request_ctx(req);
74 *subreq = *req;
75
76 if (!crypto_simd_usable() ||
77 (in_atomic() && cryptd_skcipher_queued(ctx->cryptd_tfm)))
78 child = &ctx->cryptd_tfm->base;
79 else
80 child = cryptd_skcipher_child(ctx->cryptd_tfm);
81
82 skcipher_request_set_tfm(subreq, child);
83
84 return crypto_skcipher_encrypt(subreq);
85}
86
87static int simd_skcipher_decrypt(struct skcipher_request *req)
88{
89 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
90 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
91 struct skcipher_request *subreq;
92 struct crypto_skcipher *child;
93
94 subreq = skcipher_request_ctx(req);
95 *subreq = *req;
96
97 if (!crypto_simd_usable() ||
98 (in_atomic() && cryptd_skcipher_queued(ctx->cryptd_tfm)))
99 child = &ctx->cryptd_tfm->base;
100 else
101 child = cryptd_skcipher_child(ctx->cryptd_tfm);
102
103 skcipher_request_set_tfm(subreq, child);
104
105 return crypto_skcipher_decrypt(subreq);
106}
107
108static void simd_skcipher_exit(struct crypto_skcipher *tfm)
109{
110 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
111
112 cryptd_free_skcipher(ctx->cryptd_tfm);
113}
114
115static int simd_skcipher_init(struct crypto_skcipher *tfm)
116{
117 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
118 struct cryptd_skcipher *cryptd_tfm;
119 struct simd_skcipher_alg *salg;
120 struct skcipher_alg *alg;
121 unsigned reqsize;
122
123 alg = crypto_skcipher_alg(tfm);
124 salg = container_of(alg, struct simd_skcipher_alg, alg);
125
126 cryptd_tfm = cryptd_alloc_skcipher(salg->ialg_name,
127 CRYPTO_ALG_INTERNAL,
128 CRYPTO_ALG_INTERNAL);
129 if (IS_ERR(cryptd_tfm))
130 return PTR_ERR(cryptd_tfm);
131
132 ctx->cryptd_tfm = cryptd_tfm;
133
134 reqsize = crypto_skcipher_reqsize(cryptd_skcipher_child(cryptd_tfm));
135 reqsize = max(reqsize, crypto_skcipher_reqsize(&cryptd_tfm->base));
136 reqsize += sizeof(struct skcipher_request);
137
138 crypto_skcipher_set_reqsize(tfm, reqsize);
139
140 return 0;
141}
142
143struct simd_skcipher_alg *simd_skcipher_create_compat(const char *algname,
144 const char *drvname,
145 const char *basename)
146{
147 struct simd_skcipher_alg *salg;
148 struct crypto_skcipher *tfm;
149 struct skcipher_alg *ialg;
150 struct skcipher_alg *alg;
151 int err;
152
153 tfm = crypto_alloc_skcipher(basename, CRYPTO_ALG_INTERNAL,
154 CRYPTO_ALG_INTERNAL | CRYPTO_ALG_ASYNC);
155 if (IS_ERR(tfm))
156 return ERR_CAST(tfm);
157
158 ialg = crypto_skcipher_alg(tfm);
159
160 salg = kzalloc(sizeof(*salg), GFP_KERNEL);
161 if (!salg) {
162 salg = ERR_PTR(-ENOMEM);
163 goto out_put_tfm;
164 }
165
166 salg->ialg_name = basename;
167 alg = &salg->alg;
168
169 err = -ENAMETOOLONG;
170 if (snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", algname) >=
171 CRYPTO_MAX_ALG_NAME)
172 goto out_free_salg;
173
174 if (snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
175 drvname) >= CRYPTO_MAX_ALG_NAME)
176 goto out_free_salg;
177
178 alg->base.cra_flags = CRYPTO_ALG_ASYNC;
179 alg->base.cra_priority = ialg->base.cra_priority;
180 alg->base.cra_blocksize = ialg->base.cra_blocksize;
181 alg->base.cra_alignmask = ialg->base.cra_alignmask;
182 alg->base.cra_module = ialg->base.cra_module;
183 alg->base.cra_ctxsize = sizeof(struct simd_skcipher_ctx);
184
185 alg->ivsize = ialg->ivsize;
186 alg->chunksize = ialg->chunksize;
187 alg->min_keysize = ialg->min_keysize;
188 alg->max_keysize = ialg->max_keysize;
189
190 alg->init = simd_skcipher_init;
191 alg->exit = simd_skcipher_exit;
192
193 alg->setkey = simd_skcipher_setkey;
194 alg->encrypt = simd_skcipher_encrypt;
195 alg->decrypt = simd_skcipher_decrypt;
196
197 err = crypto_register_skcipher(alg);
198 if (err)
199 goto out_free_salg;
200
201out_put_tfm:
202 crypto_free_skcipher(tfm);
203 return salg;
204
205out_free_salg:
206 kfree(salg);
207 salg = ERR_PTR(err);
208 goto out_put_tfm;
209}
210EXPORT_SYMBOL_GPL(simd_skcipher_create_compat);
211
212struct simd_skcipher_alg *simd_skcipher_create(const char *algname,
213 const char *basename)
214{
215 char drvname[CRYPTO_MAX_ALG_NAME];
216
217 if (snprintf(drvname, CRYPTO_MAX_ALG_NAME, "simd-%s", basename) >=
218 CRYPTO_MAX_ALG_NAME)
219 return ERR_PTR(-ENAMETOOLONG);
220
221 return simd_skcipher_create_compat(algname, drvname, basename);
222}
223EXPORT_SYMBOL_GPL(simd_skcipher_create);
224
225void simd_skcipher_free(struct simd_skcipher_alg *salg)
226{
227 crypto_unregister_skcipher(&salg->alg);
228 kfree(salg);
229}
230EXPORT_SYMBOL_GPL(simd_skcipher_free);
231
232int simd_register_skciphers_compat(struct skcipher_alg *algs, int count,
233 struct simd_skcipher_alg **simd_algs)
234{
235 int err;
236 int i;
237 const char *algname;
238 const char *drvname;
239 const char *basename;
240 struct simd_skcipher_alg *simd;
241
242 err = crypto_register_skciphers(algs, count);
243 if (err)
244 return err;
245
246 for (i = 0; i < count; i++) {
247 WARN_ON(strncmp(algs[i].base.cra_name, "__", 2));
248 WARN_ON(strncmp(algs[i].base.cra_driver_name, "__", 2));
249 algname = algs[i].base.cra_name + 2;
250 drvname = algs[i].base.cra_driver_name + 2;
251 basename = algs[i].base.cra_driver_name;
252 simd = simd_skcipher_create_compat(algname, drvname, basename);
253 err = PTR_ERR(simd);
254 if (IS_ERR(simd))
255 goto err_unregister;
256 simd_algs[i] = simd;
257 }
258 return 0;
259
260err_unregister:
261 simd_unregister_skciphers(algs, count, simd_algs);
262 return err;
263}
264EXPORT_SYMBOL_GPL(simd_register_skciphers_compat);
265
266void simd_unregister_skciphers(struct skcipher_alg *algs, int count,
267 struct simd_skcipher_alg **simd_algs)
268{
269 int i;
270
271 crypto_unregister_skciphers(algs, count);
272
273 for (i = 0; i < count; i++) {
274 if (simd_algs[i]) {
275 simd_skcipher_free(simd_algs[i]);
276 simd_algs[i] = NULL;
277 }
278 }
279}
280EXPORT_SYMBOL_GPL(simd_unregister_skciphers);
281
282/* AEAD support */
283
284struct simd_aead_alg {
285 const char *ialg_name;
286 struct aead_alg alg;
287};
288
289struct simd_aead_ctx {
290 struct cryptd_aead *cryptd_tfm;
291};
292
293static int simd_aead_setkey(struct crypto_aead *tfm, const u8 *key,
294 unsigned int key_len)
295{
296 struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
297 struct crypto_aead *child = &ctx->cryptd_tfm->base;
298 int err;
299
300 crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK);
301 crypto_aead_set_flags(child, crypto_aead_get_flags(tfm) &
302 CRYPTO_TFM_REQ_MASK);
303 err = crypto_aead_setkey(child, key, key_len);
304 crypto_aead_set_flags(tfm, crypto_aead_get_flags(child) &
305 CRYPTO_TFM_RES_MASK);
306 return err;
307}
308
309static int simd_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize)
310{
311 struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
312 struct crypto_aead *child = &ctx->cryptd_tfm->base;
313
314 return crypto_aead_setauthsize(child, authsize);
315}
316
317static int simd_aead_encrypt(struct aead_request *req)
318{
319 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
320 struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
321 struct aead_request *subreq;
322 struct crypto_aead *child;
323
324 subreq = aead_request_ctx(req);
325 *subreq = *req;
326
327 if (!crypto_simd_usable() ||
328 (in_atomic() && cryptd_aead_queued(ctx->cryptd_tfm)))
329 child = &ctx->cryptd_tfm->base;
330 else
331 child = cryptd_aead_child(ctx->cryptd_tfm);
332
333 aead_request_set_tfm(subreq, child);
334
335 return crypto_aead_encrypt(subreq);
336}
337
338static int simd_aead_decrypt(struct aead_request *req)
339{
340 struct crypto_aead *tfm = crypto_aead_reqtfm(req);
341 struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
342 struct aead_request *subreq;
343 struct crypto_aead *child;
344
345 subreq = aead_request_ctx(req);
346 *subreq = *req;
347
348 if (!crypto_simd_usable() ||
349 (in_atomic() && cryptd_aead_queued(ctx->cryptd_tfm)))
350 child = &ctx->cryptd_tfm->base;
351 else
352 child = cryptd_aead_child(ctx->cryptd_tfm);
353
354 aead_request_set_tfm(subreq, child);
355
356 return crypto_aead_decrypt(subreq);
357}
358
359static void simd_aead_exit(struct crypto_aead *tfm)
360{
361 struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
362
363 cryptd_free_aead(ctx->cryptd_tfm);
364}
365
366static int simd_aead_init(struct crypto_aead *tfm)
367{
368 struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
369 struct cryptd_aead *cryptd_tfm;
370 struct simd_aead_alg *salg;
371 struct aead_alg *alg;
372 unsigned reqsize;
373
374 alg = crypto_aead_alg(tfm);
375 salg = container_of(alg, struct simd_aead_alg, alg);
376
377 cryptd_tfm = cryptd_alloc_aead(salg->ialg_name, CRYPTO_ALG_INTERNAL,
378 CRYPTO_ALG_INTERNAL);
379 if (IS_ERR(cryptd_tfm))
380 return PTR_ERR(cryptd_tfm);
381
382 ctx->cryptd_tfm = cryptd_tfm;
383
384 reqsize = crypto_aead_reqsize(cryptd_aead_child(cryptd_tfm));
385 reqsize = max(reqsize, crypto_aead_reqsize(&cryptd_tfm->base));
386 reqsize += sizeof(struct aead_request);
387
388 crypto_aead_set_reqsize(tfm, reqsize);
389
390 return 0;
391}
392
393struct simd_aead_alg *simd_aead_create_compat(const char *algname,
394 const char *drvname,
395 const char *basename)
396{
397 struct simd_aead_alg *salg;
398 struct crypto_aead *tfm;
399 struct aead_alg *ialg;
400 struct aead_alg *alg;
401 int err;
402
403 tfm = crypto_alloc_aead(basename, CRYPTO_ALG_INTERNAL,
404 CRYPTO_ALG_INTERNAL | CRYPTO_ALG_ASYNC);
405 if (IS_ERR(tfm))
406 return ERR_CAST(tfm);
407
408 ialg = crypto_aead_alg(tfm);
409
410 salg = kzalloc(sizeof(*salg), GFP_KERNEL);
411 if (!salg) {
412 salg = ERR_PTR(-ENOMEM);
413 goto out_put_tfm;
414 }
415
416 salg->ialg_name = basename;
417 alg = &salg->alg;
418
419 err = -ENAMETOOLONG;
420 if (snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", algname) >=
421 CRYPTO_MAX_ALG_NAME)
422 goto out_free_salg;
423
424 if (snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
425 drvname) >= CRYPTO_MAX_ALG_NAME)
426 goto out_free_salg;
427
428 alg->base.cra_flags = CRYPTO_ALG_ASYNC;
429 alg->base.cra_priority = ialg->base.cra_priority;
430 alg->base.cra_blocksize = ialg->base.cra_blocksize;
431 alg->base.cra_alignmask = ialg->base.cra_alignmask;
432 alg->base.cra_module = ialg->base.cra_module;
433 alg->base.cra_ctxsize = sizeof(struct simd_aead_ctx);
434
435 alg->ivsize = ialg->ivsize;
436 alg->maxauthsize = ialg->maxauthsize;
437 alg->chunksize = ialg->chunksize;
438
439 alg->init = simd_aead_init;
440 alg->exit = simd_aead_exit;
441
442 alg->setkey = simd_aead_setkey;
443 alg->setauthsize = simd_aead_setauthsize;
444 alg->encrypt = simd_aead_encrypt;
445 alg->decrypt = simd_aead_decrypt;
446
447 err = crypto_register_aead(alg);
448 if (err)
449 goto out_free_salg;
450
451out_put_tfm:
452 crypto_free_aead(tfm);
453 return salg;
454
455out_free_salg:
456 kfree(salg);
457 salg = ERR_PTR(err);
458 goto out_put_tfm;
459}
460EXPORT_SYMBOL_GPL(simd_aead_create_compat);
461
462struct simd_aead_alg *simd_aead_create(const char *algname,
463 const char *basename)
464{
465 char drvname[CRYPTO_MAX_ALG_NAME];
466
467 if (snprintf(drvname, CRYPTO_MAX_ALG_NAME, "simd-%s", basename) >=
468 CRYPTO_MAX_ALG_NAME)
469 return ERR_PTR(-ENAMETOOLONG);
470
471 return simd_aead_create_compat(algname, drvname, basename);
472}
473EXPORT_SYMBOL_GPL(simd_aead_create);
474
475void simd_aead_free(struct simd_aead_alg *salg)
476{
477 crypto_unregister_aead(&salg->alg);
478 kfree(salg);
479}
480EXPORT_SYMBOL_GPL(simd_aead_free);
481
482int simd_register_aeads_compat(struct aead_alg *algs, int count,
483 struct simd_aead_alg **simd_algs)
484{
485 int err;
486 int i;
487 const char *algname;
488 const char *drvname;
489 const char *basename;
490 struct simd_aead_alg *simd;
491
492 err = crypto_register_aeads(algs, count);
493 if (err)
494 return err;
495
496 for (i = 0; i < count; i++) {
497 WARN_ON(strncmp(algs[i].base.cra_name, "__", 2));
498 WARN_ON(strncmp(algs[i].base.cra_driver_name, "__", 2));
499 algname = algs[i].base.cra_name + 2;
500 drvname = algs[i].base.cra_driver_name + 2;
501 basename = algs[i].base.cra_driver_name;
502 simd = simd_aead_create_compat(algname, drvname, basename);
503 err = PTR_ERR(simd);
504 if (IS_ERR(simd))
505 goto err_unregister;
506 simd_algs[i] = simd;
507 }
508 return 0;
509
510err_unregister:
511 simd_unregister_aeads(algs, count, simd_algs);
512 return err;
513}
514EXPORT_SYMBOL_GPL(simd_register_aeads_compat);
515
516void simd_unregister_aeads(struct aead_alg *algs, int count,
517 struct simd_aead_alg **simd_algs)
518{
519 int i;
520
521 crypto_unregister_aeads(algs, count);
522
523 for (i = 0; i < count; i++) {
524 if (simd_algs[i]) {
525 simd_aead_free(simd_algs[i]);
526 simd_algs[i] = NULL;
527 }
528 }
529}
530EXPORT_SYMBOL_GPL(simd_unregister_aeads);
531
532MODULE_LICENSE("GPL");
1/*
2 * Shared crypto simd helpers
3 *
4 * Copyright (c) 2012 Jussi Kivilinna <jussi.kivilinna@mbnet.fi>
5 * Copyright (c) 2016 Herbert Xu <herbert@gondor.apana.org.au>
6 *
7 * Based on aesni-intel_glue.c by:
8 * Copyright (C) 2008, Intel Corp.
9 * Author: Huang Ying <ying.huang@intel.com>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program. If not, see <http://www.gnu.org/licenses/>.
23 *
24 */
25
26#include <crypto/cryptd.h>
27#include <crypto/internal/simd.h>
28#include <crypto/internal/skcipher.h>
29#include <linux/kernel.h>
30#include <linux/module.h>
31#include <linux/preempt.h>
32#include <asm/simd.h>
33
34struct simd_skcipher_alg {
35 const char *ialg_name;
36 struct skcipher_alg alg;
37};
38
39struct simd_skcipher_ctx {
40 struct cryptd_skcipher *cryptd_tfm;
41};
42
43static int simd_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key,
44 unsigned int key_len)
45{
46 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
47 struct crypto_skcipher *child = &ctx->cryptd_tfm->base;
48 int err;
49
50 crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
51 crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(tfm) &
52 CRYPTO_TFM_REQ_MASK);
53 err = crypto_skcipher_setkey(child, key, key_len);
54 crypto_skcipher_set_flags(tfm, crypto_skcipher_get_flags(child) &
55 CRYPTO_TFM_RES_MASK);
56 return err;
57}
58
59static int simd_skcipher_encrypt(struct skcipher_request *req)
60{
61 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
62 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
63 struct skcipher_request *subreq;
64 struct crypto_skcipher *child;
65
66 subreq = skcipher_request_ctx(req);
67 *subreq = *req;
68
69 if (!may_use_simd() ||
70 (in_atomic() && cryptd_skcipher_queued(ctx->cryptd_tfm)))
71 child = &ctx->cryptd_tfm->base;
72 else
73 child = cryptd_skcipher_child(ctx->cryptd_tfm);
74
75 skcipher_request_set_tfm(subreq, child);
76
77 return crypto_skcipher_encrypt(subreq);
78}
79
80static int simd_skcipher_decrypt(struct skcipher_request *req)
81{
82 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
83 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
84 struct skcipher_request *subreq;
85 struct crypto_skcipher *child;
86
87 subreq = skcipher_request_ctx(req);
88 *subreq = *req;
89
90 if (!may_use_simd() ||
91 (in_atomic() && cryptd_skcipher_queued(ctx->cryptd_tfm)))
92 child = &ctx->cryptd_tfm->base;
93 else
94 child = cryptd_skcipher_child(ctx->cryptd_tfm);
95
96 skcipher_request_set_tfm(subreq, child);
97
98 return crypto_skcipher_decrypt(subreq);
99}
100
101static void simd_skcipher_exit(struct crypto_skcipher *tfm)
102{
103 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
104
105 cryptd_free_skcipher(ctx->cryptd_tfm);
106}
107
108static int simd_skcipher_init(struct crypto_skcipher *tfm)
109{
110 struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
111 struct cryptd_skcipher *cryptd_tfm;
112 struct simd_skcipher_alg *salg;
113 struct skcipher_alg *alg;
114 unsigned reqsize;
115
116 alg = crypto_skcipher_alg(tfm);
117 salg = container_of(alg, struct simd_skcipher_alg, alg);
118
119 cryptd_tfm = cryptd_alloc_skcipher(salg->ialg_name,
120 CRYPTO_ALG_INTERNAL,
121 CRYPTO_ALG_INTERNAL);
122 if (IS_ERR(cryptd_tfm))
123 return PTR_ERR(cryptd_tfm);
124
125 ctx->cryptd_tfm = cryptd_tfm;
126
127 reqsize = sizeof(struct skcipher_request);
128 reqsize += crypto_skcipher_reqsize(&cryptd_tfm->base);
129
130 crypto_skcipher_set_reqsize(tfm, reqsize);
131
132 return 0;
133}
134
135struct simd_skcipher_alg *simd_skcipher_create_compat(const char *algname,
136 const char *drvname,
137 const char *basename)
138{
139 struct simd_skcipher_alg *salg;
140 struct crypto_skcipher *tfm;
141 struct skcipher_alg *ialg;
142 struct skcipher_alg *alg;
143 int err;
144
145 tfm = crypto_alloc_skcipher(basename, CRYPTO_ALG_INTERNAL,
146 CRYPTO_ALG_INTERNAL | CRYPTO_ALG_ASYNC);
147 if (IS_ERR(tfm))
148 return ERR_CAST(tfm);
149
150 ialg = crypto_skcipher_alg(tfm);
151
152 salg = kzalloc(sizeof(*salg), GFP_KERNEL);
153 if (!salg) {
154 salg = ERR_PTR(-ENOMEM);
155 goto out_put_tfm;
156 }
157
158 salg->ialg_name = basename;
159 alg = &salg->alg;
160
161 err = -ENAMETOOLONG;
162 if (snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", algname) >=
163 CRYPTO_MAX_ALG_NAME)
164 goto out_free_salg;
165
166 if (snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
167 drvname) >= CRYPTO_MAX_ALG_NAME)
168 goto out_free_salg;
169
170 alg->base.cra_flags = CRYPTO_ALG_ASYNC;
171 alg->base.cra_priority = ialg->base.cra_priority;
172 alg->base.cra_blocksize = ialg->base.cra_blocksize;
173 alg->base.cra_alignmask = ialg->base.cra_alignmask;
174 alg->base.cra_module = ialg->base.cra_module;
175 alg->base.cra_ctxsize = sizeof(struct simd_skcipher_ctx);
176
177 alg->ivsize = ialg->ivsize;
178 alg->chunksize = ialg->chunksize;
179 alg->min_keysize = ialg->min_keysize;
180 alg->max_keysize = ialg->max_keysize;
181
182 alg->init = simd_skcipher_init;
183 alg->exit = simd_skcipher_exit;
184
185 alg->setkey = simd_skcipher_setkey;
186 alg->encrypt = simd_skcipher_encrypt;
187 alg->decrypt = simd_skcipher_decrypt;
188
189 err = crypto_register_skcipher(alg);
190 if (err)
191 goto out_free_salg;
192
193out_put_tfm:
194 crypto_free_skcipher(tfm);
195 return salg;
196
197out_free_salg:
198 kfree(salg);
199 salg = ERR_PTR(err);
200 goto out_put_tfm;
201}
202EXPORT_SYMBOL_GPL(simd_skcipher_create_compat);
203
204struct simd_skcipher_alg *simd_skcipher_create(const char *algname,
205 const char *basename)
206{
207 char drvname[CRYPTO_MAX_ALG_NAME];
208
209 if (snprintf(drvname, CRYPTO_MAX_ALG_NAME, "simd-%s", basename) >=
210 CRYPTO_MAX_ALG_NAME)
211 return ERR_PTR(-ENAMETOOLONG);
212
213 return simd_skcipher_create_compat(algname, drvname, basename);
214}
215EXPORT_SYMBOL_GPL(simd_skcipher_create);
216
217void simd_skcipher_free(struct simd_skcipher_alg *salg)
218{
219 crypto_unregister_skcipher(&salg->alg);
220 kfree(salg);
221}
222EXPORT_SYMBOL_GPL(simd_skcipher_free);
223
224int simd_register_skciphers_compat(struct skcipher_alg *algs, int count,
225 struct simd_skcipher_alg **simd_algs)
226{
227 int err;
228 int i;
229 const char *algname;
230 const char *drvname;
231 const char *basename;
232 struct simd_skcipher_alg *simd;
233
234 err = crypto_register_skciphers(algs, count);
235 if (err)
236 return err;
237
238 for (i = 0; i < count; i++) {
239 WARN_ON(strncmp(algs[i].base.cra_name, "__", 2));
240 WARN_ON(strncmp(algs[i].base.cra_driver_name, "__", 2));
241 algname = algs[i].base.cra_name + 2;
242 drvname = algs[i].base.cra_driver_name + 2;
243 basename = algs[i].base.cra_driver_name;
244 simd = simd_skcipher_create_compat(algname, drvname, basename);
245 err = PTR_ERR(simd);
246 if (IS_ERR(simd))
247 goto err_unregister;
248 simd_algs[i] = simd;
249 }
250 return 0;
251
252err_unregister:
253 simd_unregister_skciphers(algs, count, simd_algs);
254 return err;
255}
256EXPORT_SYMBOL_GPL(simd_register_skciphers_compat);
257
258void simd_unregister_skciphers(struct skcipher_alg *algs, int count,
259 struct simd_skcipher_alg **simd_algs)
260{
261 int i;
262
263 crypto_unregister_skciphers(algs, count);
264
265 for (i = 0; i < count; i++) {
266 if (simd_algs[i]) {
267 simd_skcipher_free(simd_algs[i]);
268 simd_algs[i] = NULL;
269 }
270 }
271}
272EXPORT_SYMBOL_GPL(simd_unregister_skciphers);
273
274MODULE_LICENSE("GPL");