Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: api - Add support for duplicating algorithms before registration
If the bit CRYPTO_ALG_DUP_FIRST is set, an algorithm will be
duplicated by kmemdup before registration. This is inteded for
hardware-based algorithms that may be unplugged at will.
Do not use this if the algorithm data structure is embedded in a
bigger data structure. Perform the duplication in the driver
instead.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
+61
-14
+1
crypto/acompress.c
+1
crypto/acompress.c
···
150
150
.maskset = CRYPTO_ALG_TYPE_ACOMPRESS_MASK,
151
151
.type = CRYPTO_ALG_TYPE_ACOMPRESS,
152
152
.tfmsize = offsetof(struct crypto_acomp, base),
153
+
.algsize = offsetof(struct acomp_alg, base),
153
154
};
154
155
155
156
struct crypto_acomp *crypto_alloc_acomp(const char *alg_name, u32 type,
+1
crypto/aead.c
+1
crypto/aead.c
+1
crypto/ahash.c
+1
crypto/ahash.c
+1
crypto/akcipher.c
+1
crypto/akcipher.c
+28
-13
crypto/algapi.c
+28
-13
crypto/algapi.c
···
66
66
67
67
static void crypto_free_instance(struct crypto_instance *inst)
68
68
{
69
-
struct crypto_alg *alg = &inst->alg;
70
-
const struct crypto_type *type;
71
-
72
-
type = alg->cra_type;
73
-
if (type->destroy)
74
-
type->destroy(alg);
75
-
type->free(inst);
69
+
inst->alg.cra_type->free(inst);
76
70
}
77
71
78
72
static void crypto_destroy_instance_workfn(struct work_struct *w)
···
418
424
}
419
425
EXPORT_SYMBOL_GPL(crypto_remove_final);
420
426
427
+
static void crypto_free_alg(struct crypto_alg *alg)
428
+
{
429
+
unsigned int algsize = alg->cra_type->algsize;
430
+
u8 *p = (u8 *)alg - algsize;
431
+
432
+
crypto_destroy_alg(alg);
433
+
kfree(p);
434
+
}
435
+
421
436
int crypto_register_alg(struct crypto_alg *alg)
422
437
{
423
438
struct crypto_larval *larval;
···
439
436
if (err)
440
437
return err;
441
438
439
+
if (alg->cra_flags & CRYPTO_ALG_DUP_FIRST &&
440
+
!WARN_ON_ONCE(alg->cra_destroy)) {
441
+
unsigned int algsize = alg->cra_type->algsize;
442
+
u8 *p = (u8 *)alg - algsize;
443
+
444
+
p = kmemdup(p, algsize + sizeof(*alg), GFP_KERNEL);
445
+
if (!p)
446
+
return -ENOMEM;
447
+
448
+
alg = (void *)(p + algsize);
449
+
alg->cra_destroy = crypto_free_alg;
450
+
}
451
+
442
452
down_write(&crypto_alg_sem);
443
453
larval = __crypto_register_alg(alg, &algs_to_put);
444
454
if (!IS_ERR_OR_NULL(larval)) {
···
460
444
}
461
445
up_write(&crypto_alg_sem);
462
446
463
-
if (IS_ERR(larval))
447
+
if (IS_ERR(larval)) {
448
+
crypto_alg_put(alg);
464
449
return PTR_ERR(larval);
450
+
}
465
451
466
452
if (test_started)
467
453
crypto_schedule_test(larval);
···
499
481
if (WARN(ret, "Algorithm %s is not registered", alg->cra_driver_name))
500
482
return;
501
483
502
-
if (alg->cra_destroy)
503
-
crypto_alg_put(alg);
504
-
else if (!WARN_ON(refcount_read(&alg->cra_refcnt) != 1) &&
505
-
alg->cra_type && alg->cra_type->destroy)
506
-
alg->cra_type->destroy(alg);
484
+
WARN_ON(!alg->cra_destroy && refcount_read(&alg->cra_refcnt) != 1);
507
485
486
+
list_add(&alg->cra_list, &list);
508
487
crypto_remove_final(&list);
509
488
}
510
489
EXPORT_SYMBOL_GPL(crypto_unregister_alg);
+9
crypto/api.c
+9
crypto/api.c
···
703
703
}
704
704
EXPORT_SYMBOL_GPL(crypto_req_done);
705
705
706
+
void crypto_destroy_alg(struct crypto_alg *alg)
707
+
{
708
+
if (alg->cra_type && alg->cra_type->destroy)
709
+
alg->cra_type->destroy(alg);
710
+
if (alg->cra_destroy)
711
+
alg->cra_destroy(alg);
712
+
}
713
+
EXPORT_SYMBOL_GPL(crypto_destroy_alg);
714
+
706
715
MODULE_DESCRIPTION("Cryptographic core API");
707
716
MODULE_LICENSE("GPL");
+4
-1
crypto/internal.h
+4
-1
crypto/internal.h
···
46
46
unsigned int maskclear;
47
47
unsigned int maskset;
48
48
unsigned int tfmsize;
49
+
unsigned int algsize;
49
50
};
50
51
51
52
enum {
···
163
162
return alg;
164
163
}
165
164
165
+
void crypto_destroy_alg(struct crypto_alg *alg);
166
+
166
167
static inline void crypto_alg_put(struct crypto_alg *alg)
167
168
{
168
169
if (refcount_dec_and_test(&alg->cra_refcnt))
169
-
alg->cra_destroy(alg);
170
+
crypto_destroy_alg(alg);
170
171
}
171
172
172
173
static inline int crypto_tmpl_get(struct crypto_template *tmpl)
+1
crypto/kpp.c
+1
crypto/kpp.c
+1
crypto/lskcipher.c
+1
crypto/lskcipher.c
+1
crypto/rng.c
+1
crypto/rng.c
+1
crypto/scompress.c
+1
crypto/scompress.c
+1
crypto/shash.c
+1
crypto/shash.c
+1
crypto/sig.c
+1
crypto/sig.c
+1
crypto/skcipher.c
+1
crypto/skcipher.c
+9
include/linux/crypto.h
+9
include/linux/crypto.h
···
50
50
#define CRYPTO_ALG_NEED_FALLBACK 0x00000100
51
51
52
52
/*
53
+
* Set if the algorithm data structure should be duplicated into
54
+
* kmalloc memory before registration. This is useful for hardware
55
+
* that can be disconnected at will. Do not use this if the data
56
+
* structure is embedded into a bigger one. Duplicate the overall
57
+
* data structure in the driver in that case.
58
+
*/
59
+
#define CRYPTO_ALG_DUP_FIRST 0x00000200
60
+
61
+
/*
53
62
* Set if the algorithm has passed automated run-time testing. Note that
54
63
* if there is no run-time testing for a given algorithm it is considered
55
64
* to have passed.