Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: simd - Do not call crypto_alloc_tfm during registration
Algorithm registration is usually carried out during module init,
where as little work as possible should be carried out. The SIMD
code violated this rule by allocating a tfm, this then triggers a
full test of the algorithm which may dead-lock in certain cases.
SIMD is only allocating the tfm to get at the alg object, which is
in fact already available as it is what we are registering. Use
that directly and remove the crypto_alloc_tfm call.
Also remove some obsolete and unused SIMD API.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
+19
-73
+1
-1
arch/arm/crypto/aes-ce-glue.c
+1
-1
arch/arm/crypto/aes-ce-glue.c
···
711
711
algname = aes_algs[i].base.cra_name + 2;
712
712
drvname = aes_algs[i].base.cra_driver_name + 2;
713
713
basename = aes_algs[i].base.cra_driver_name;
714
-
simd = simd_skcipher_create_compat(algname, drvname, basename);
714
+
simd = simd_skcipher_create_compat(aes_algs + i, algname, drvname, basename);
715
715
err = PTR_ERR(simd);
716
716
if (IS_ERR(simd))
717
717
goto unregister_simds;
+1
-1
arch/arm/crypto/aes-neonbs-glue.c
+1
-1
arch/arm/crypto/aes-neonbs-glue.c
···
491
491
algname = aes_algs[i].base.cra_name + 2;
492
492
drvname = aes_algs[i].base.cra_driver_name + 2;
493
493
basename = aes_algs[i].base.cra_driver_name;
494
-
simd = simd_skcipher_create_compat(algname, drvname, basename);
494
+
simd = simd_skcipher_create_compat(aes_algs + i, algname, drvname, basename);
495
495
err = PTR_ERR(simd);
496
496
if (IS_ERR(simd))
497
497
goto unregister_simds;
+15
-61
crypto/simd.c
+15
-61
crypto/simd.c
···
136
136
return 0;
137
137
}
138
138
139
-
struct simd_skcipher_alg *simd_skcipher_create_compat(const char *algname,
139
+
struct simd_skcipher_alg *simd_skcipher_create_compat(struct skcipher_alg *ialg,
140
+
const char *algname,
140
141
const char *drvname,
141
142
const char *basename)
142
143
{
143
144
struct simd_skcipher_alg *salg;
144
-
struct crypto_skcipher *tfm;
145
-
struct skcipher_alg *ialg;
146
145
struct skcipher_alg *alg;
147
146
int err;
148
-
149
-
tfm = crypto_alloc_skcipher(basename, CRYPTO_ALG_INTERNAL,
150
-
CRYPTO_ALG_INTERNAL | CRYPTO_ALG_ASYNC);
151
-
if (IS_ERR(tfm))
152
-
return ERR_CAST(tfm);
153
-
154
-
ialg = crypto_skcipher_alg(tfm);
155
147
156
148
salg = kzalloc(sizeof(*salg), GFP_KERNEL);
157
149
if (!salg) {
158
150
salg = ERR_PTR(-ENOMEM);
159
-
goto out_put_tfm;
151
+
goto out;
160
152
}
161
153
162
154
salg->ialg_name = basename;
···
187
195
if (err)
188
196
goto out_free_salg;
189
197
190
-
out_put_tfm:
191
-
crypto_free_skcipher(tfm);
198
+
out:
192
199
return salg;
193
200
194
201
out_free_salg:
195
202
kfree(salg);
196
203
salg = ERR_PTR(err);
197
-
goto out_put_tfm;
204
+
goto out;
198
205
}
199
206
EXPORT_SYMBOL_GPL(simd_skcipher_create_compat);
200
-
201
-
struct simd_skcipher_alg *simd_skcipher_create(const char *algname,
202
-
const char *basename)
203
-
{
204
-
char drvname[CRYPTO_MAX_ALG_NAME];
205
-
206
-
if (snprintf(drvname, CRYPTO_MAX_ALG_NAME, "simd-%s", basename) >=
207
-
CRYPTO_MAX_ALG_NAME)
208
-
return ERR_PTR(-ENAMETOOLONG);
209
-
210
-
return simd_skcipher_create_compat(algname, drvname, basename);
211
-
}
212
-
EXPORT_SYMBOL_GPL(simd_skcipher_create);
213
207
214
208
void simd_skcipher_free(struct simd_skcipher_alg *salg)
215
209
{
···
224
246
algname = algs[i].base.cra_name + 2;
225
247
drvname = algs[i].base.cra_driver_name + 2;
226
248
basename = algs[i].base.cra_driver_name;
227
-
simd = simd_skcipher_create_compat(algname, drvname, basename);
249
+
simd = simd_skcipher_create_compat(algs + i, algname, drvname, basename);
228
250
err = PTR_ERR(simd);
229
251
if (IS_ERR(simd))
230
252
goto err_unregister;
···
361
383
return 0;
362
384
}
363
385
364
-
struct simd_aead_alg *simd_aead_create_compat(const char *algname,
365
-
const char *drvname,
366
-
const char *basename)
386
+
static struct simd_aead_alg *simd_aead_create_compat(struct aead_alg *ialg,
387
+
const char *algname,
388
+
const char *drvname,
389
+
const char *basename)
367
390
{
368
391
struct simd_aead_alg *salg;
369
-
struct crypto_aead *tfm;
370
-
struct aead_alg *ialg;
371
392
struct aead_alg *alg;
372
393
int err;
373
-
374
-
tfm = crypto_alloc_aead(basename, CRYPTO_ALG_INTERNAL,
375
-
CRYPTO_ALG_INTERNAL | CRYPTO_ALG_ASYNC);
376
-
if (IS_ERR(tfm))
377
-
return ERR_CAST(tfm);
378
-
379
-
ialg = crypto_aead_alg(tfm);
380
394
381
395
salg = kzalloc(sizeof(*salg), GFP_KERNEL);
382
396
if (!salg) {
383
397
salg = ERR_PTR(-ENOMEM);
384
-
goto out_put_tfm;
398
+
goto out;
385
399
}
386
400
387
401
salg->ialg_name = basename;
···
412
442
if (err)
413
443
goto out_free_salg;
414
444
415
-
out_put_tfm:
416
-
crypto_free_aead(tfm);
445
+
out:
417
446
return salg;
418
447
419
448
out_free_salg:
420
449
kfree(salg);
421
450
salg = ERR_PTR(err);
422
-
goto out_put_tfm;
451
+
goto out;
423
452
}
424
-
EXPORT_SYMBOL_GPL(simd_aead_create_compat);
425
453
426
-
struct simd_aead_alg *simd_aead_create(const char *algname,
427
-
const char *basename)
428
-
{
429
-
char drvname[CRYPTO_MAX_ALG_NAME];
430
-
431
-
if (snprintf(drvname, CRYPTO_MAX_ALG_NAME, "simd-%s", basename) >=
432
-
CRYPTO_MAX_ALG_NAME)
433
-
return ERR_PTR(-ENAMETOOLONG);
434
-
435
-
return simd_aead_create_compat(algname, drvname, basename);
436
-
}
437
-
EXPORT_SYMBOL_GPL(simd_aead_create);
438
-
439
-
void simd_aead_free(struct simd_aead_alg *salg)
454
+
static void simd_aead_free(struct simd_aead_alg *salg)
440
455
{
441
456
crypto_unregister_aead(&salg->alg);
442
457
kfree(salg);
443
458
}
444
-
EXPORT_SYMBOL_GPL(simd_aead_free);
445
459
446
460
int simd_register_aeads_compat(struct aead_alg *algs, int count,
447
461
struct simd_aead_alg **simd_algs)
···
447
493
algname = algs[i].base.cra_name + 2;
448
494
drvname = algs[i].base.cra_driver_name + 2;
449
495
basename = algs[i].base.cra_driver_name;
450
-
simd = simd_aead_create_compat(algname, drvname, basename);
496
+
simd = simd_aead_create_compat(algs + i, algname, drvname, basename);
451
497
err = PTR_ERR(simd);
452
498
if (IS_ERR(simd))
453
499
goto err_unregister;
+2
-10
include/crypto/internal/simd.h
+2
-10
include/crypto/internal/simd.h
···
14
14
struct simd_skcipher_alg;
15
15
struct skcipher_alg;
16
16
17
-
struct simd_skcipher_alg *simd_skcipher_create_compat(const char *algname,
17
+
struct simd_skcipher_alg *simd_skcipher_create_compat(struct skcipher_alg *ialg,
18
+
const char *algname,
18
19
const char *drvname,
19
20
const char *basename);
20
-
struct simd_skcipher_alg *simd_skcipher_create(const char *algname,
21
-
const char *basename);
22
21
void simd_skcipher_free(struct simd_skcipher_alg *alg);
23
22
24
23
int simd_register_skciphers_compat(struct skcipher_alg *algs, int count,
···
30
31
31
32
struct simd_aead_alg;
32
33
struct aead_alg;
33
-
34
-
struct simd_aead_alg *simd_aead_create_compat(const char *algname,
35
-
const char *drvname,
36
-
const char *basename);
37
-
struct simd_aead_alg *simd_aead_create(const char *algname,
38
-
const char *basename);
39
-
void simd_aead_free(struct simd_aead_alg *alg);
40
34
41
35
int simd_register_aeads_compat(struct aead_alg *algs, int count,
42
36
struct simd_aead_alg **simd_algs);