Skip to content

Commit 6a8dbd7

Browse files
herbertxherbertx
committed
Revert "crypto: remove CONFIG_CRYPTO_STATS"
This reverts commit 2beb81f. While removing CONFIG_CRYPTO_STATS is a worthy goal, this also removed unrelated infrastructure such as crypto_comp_alg_common. Signed-off-by: Herbert Xu <[email protected]>
1 parent 77292bb commit 6a8dbd7

32 files changed

+1139
-77
lines changed

‎arch/s390/configs/debug_defconfig‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -766,6 +766,7 @@ CONFIG_CRYPTO_USER_API_HASH=m
766766
CONFIG_CRYPTO_USER_API_SKCIPHER=m
767767
CONFIG_CRYPTO_USER_API_RNG=m
768768
CONFIG_CRYPTO_USER_API_AEAD=m
769+
CONFIG_CRYPTO_STATS=y
769770
CONFIG_CRYPTO_CRC32_S390=y
770771
CONFIG_CRYPTO_SHA512_S390=m
771772
CONFIG_CRYPTO_SHA1_S390=m

‎arch/s390/configs/defconfig‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -752,6 +752,7 @@ CONFIG_CRYPTO_USER_API_HASH=m
752752
CONFIG_CRYPTO_USER_API_SKCIPHER=m
753753
CONFIG_CRYPTO_USER_API_RNG=m
754754
CONFIG_CRYPTO_USER_API_AEAD=m
755+
CONFIG_CRYPTO_STATS=y
755756
CONFIG_CRYPTO_CRC32_S390=y
756757
CONFIG_CRYPTO_SHA512_S390=m
757758
CONFIG_CRYPTO_SHA1_S390=m

‎crypto/Kconfig‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1456,6 +1456,26 @@ config CRYPTO_USER_API_ENABLE_OBSOLETE
14561456
already been phased out from internal use by the kernel, and are
14571457
only useful for userspace clients that still rely on them.
14581458

1459+
config CRYPTO_STATS
1460+
bool "Crypto usage statistics"
1461+
depends on CRYPTO_USER
1462+
help
1463+
Enable the gathering of crypto stats.
1464+
1465+
Enabling this option reduces the performance of the crypto API. It
1466+
should only be enabled when there is actually a use case for it.
1467+
1468+
This collects data sizes, numbers of requests, and numbers
1469+
of errors processed by:
1470+
- AEAD ciphers (encrypt, decrypt)
1471+
- asymmetric key ciphers (encrypt, decrypt, verify, sign)
1472+
- symmetric key ciphers (encrypt, decrypt)
1473+
- compression algorithms (compress, decompress)
1474+
- hash algorithms (hash)
1475+
- key-agreement protocol primitives (setsecret, generate
1476+
public key, compute shared secret)
1477+
- RNG (generate, seed)
1478+
14591479
endmenu
14601480

14611481
config CRYPTO_HASH_INFO

‎crypto/Makefile‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -69,6 +69,8 @@ cryptomgr-y := algboss.o testmgr.o
6969

7070
obj-$(CONFIG_CRYPTO_MANAGER2) += cryptomgr.o
7171
obj-$(CONFIG_CRYPTO_USER) += crypto_user.o
72+
crypto_user-y := crypto_user_base.o
73+
crypto_user-$(CONFIG_CRYPTO_STATS) += crypto_user_stat.o
7274
obj-$(CONFIG_CRYPTO_CMAC) += cmac.o
7375
obj-$(CONFIG_CRYPTO_HMAC) += hmac.o
7476
obj-$(CONFIG_CRYPTO_VMAC) += vmac.o

‎crypto/acompress.c‎

Lines changed: 44 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ static const struct crypto_type crypto_acomp_type;
2525

2626
static inline struct acomp_alg *__crypto_acomp_alg(struct crypto_alg *alg)
2727
{
28-
return container_of(alg, struct acomp_alg, base);
28+
return container_of(alg, struct acomp_alg, calg.base);
2929
}
3030

3131
static inline struct acomp_alg *crypto_acomp_alg(struct crypto_acomp *tfm)
@@ -93,6 +93,32 @@ static unsigned int crypto_acomp_extsize(struct crypto_alg *alg)
9393
return extsize;
9494
}
9595

96+
static inline int __crypto_acomp_report_stat(struct sk_buff *skb,
97+
struct crypto_alg *alg)
98+
{
99+
struct comp_alg_common *calg = __crypto_comp_alg_common(alg);
100+
struct crypto_istat_compress *istat = comp_get_stat(calg);
101+
struct crypto_stat_compress racomp;
102+
103+
memset(&racomp, 0, sizeof(racomp));
104+
105+
strscpy(racomp.type, "acomp", sizeof(racomp.type));
106+
racomp.stat_compress_cnt = atomic64_read(&istat->compress_cnt);
107+
racomp.stat_compress_tlen = atomic64_read(&istat->compress_tlen);
108+
racomp.stat_decompress_cnt = atomic64_read(&istat->decompress_cnt);
109+
racomp.stat_decompress_tlen = atomic64_read(&istat->decompress_tlen);
110+
racomp.stat_err_cnt = atomic64_read(&istat->err_cnt);
111+
112+
return nla_put(skb, CRYPTOCFGA_STAT_ACOMP, sizeof(racomp), &racomp);
113+
}
114+
115+
#ifdef CONFIG_CRYPTO_STATS
116+
int crypto_acomp_report_stat(struct sk_buff *skb, struct crypto_alg *alg)
117+
{
118+
return __crypto_acomp_report_stat(skb, alg);
119+
}
120+
#endif
121+
96122
static const struct crypto_type crypto_acomp_type = {
97123
.extsize = crypto_acomp_extsize,
98124
.init_tfm = crypto_acomp_init_tfm,
@@ -101,6 +127,9 @@ static const struct crypto_type crypto_acomp_type = {
101127
#endif
102128
#if IS_ENABLED(CONFIG_CRYPTO_USER)
103129
.report = crypto_acomp_report,
130+
#endif
131+
#ifdef CONFIG_CRYPTO_STATS
132+
.report_stat = crypto_acomp_report_stat,
104133
#endif
105134
.maskclear = ~CRYPTO_ALG_TYPE_MASK,
106135
.maskset = CRYPTO_ALG_TYPE_ACOMPRESS_MASK,
@@ -153,12 +182,24 @@ void acomp_request_free(struct acomp_req *req)
153182
}
154183
EXPORT_SYMBOL_GPL(acomp_request_free);
155184

156-
int crypto_register_acomp(struct acomp_alg *alg)
185+
void comp_prepare_alg(struct comp_alg_common *alg)
157186
{
187+
struct crypto_istat_compress *istat = comp_get_stat(alg);
158188
struct crypto_alg *base = &alg->base;
159189

160-
base->cra_type = &crypto_acomp_type;
161190
base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
191+
192+
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
193+
memset(istat, 0, sizeof(*istat));
194+
}
195+
196+
int crypto_register_acomp(struct acomp_alg *alg)
197+
{
198+
struct crypto_alg *base = &alg->calg.base;
199+
200+
comp_prepare_alg(&alg->calg);
201+
202+
base->cra_type = &crypto_acomp_type;
162203
base->cra_flags |= CRYPTO_ALG_TYPE_ACOMPRESS;
163204

164205
return crypto_register_alg(base);

‎crypto/aead.c‎

Lines changed: 77 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,15 @@
2020

2121
#include "internal.h"
2222

23+
static inline struct crypto_istat_aead *aead_get_stat(struct aead_alg *alg)
24+
{
25+
#ifdef CONFIG_CRYPTO_STATS
26+
return &alg->stat;
27+
#else
28+
return NULL;
29+
#endif
30+
}
31+
2332
static int setkey_unaligned(struct crypto_aead *tfm, const u8 *key,
2433
unsigned int keylen)
2534
{
@@ -81,28 +90,62 @@ int crypto_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize)
8190
}
8291
EXPORT_SYMBOL_GPL(crypto_aead_setauthsize);
8392

93+
static inline int crypto_aead_errstat(struct crypto_istat_aead *istat, int err)
94+
{
95+
if (!IS_ENABLED(CONFIG_CRYPTO_STATS))
96+
return err;
97+
98+
if (err && err != -EINPROGRESS && err != -EBUSY)
99+
atomic64_inc(&istat->err_cnt);
100+
101+
return err;
102+
}
103+
84104
int crypto_aead_encrypt(struct aead_request *req)
85105
{
86106
struct crypto_aead *aead = crypto_aead_reqtfm(req);
107+
struct aead_alg *alg = crypto_aead_alg(aead);
108+
struct crypto_istat_aead *istat;
109+
int ret;
110+
111+
istat = aead_get_stat(alg);
112+
113+
if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
114+
atomic64_inc(&istat->encrypt_cnt);
115+
atomic64_add(req->cryptlen, &istat->encrypt_tlen);
116+
}
87117

88118
if (crypto_aead_get_flags(aead) & CRYPTO_TFM_NEED_KEY)
89-
return -ENOKEY;
119+
ret = -ENOKEY;
120+
else
121+
ret = alg->encrypt(req);
90122

91-
return crypto_aead_alg(aead)->encrypt(req);
123+
return crypto_aead_errstat(istat, ret);
92124
}
93125
EXPORT_SYMBOL_GPL(crypto_aead_encrypt);
94126

95127
int crypto_aead_decrypt(struct aead_request *req)
96128
{
97129
struct crypto_aead *aead = crypto_aead_reqtfm(req);
130+
struct aead_alg *alg = crypto_aead_alg(aead);
131+
struct crypto_istat_aead *istat;
132+
int ret;
98133

99-
if (crypto_aead_get_flags(aead) & CRYPTO_TFM_NEED_KEY)
100-
return -ENOKEY;
134+
istat = aead_get_stat(alg);
101135

102-
if (req->cryptlen < crypto_aead_authsize(aead))
103-
return -EINVAL;
136+
if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
137+
atomic64_inc(&istat->encrypt_cnt);
138+
atomic64_add(req->cryptlen, &istat->encrypt_tlen);
139+
}
140+
141+
if (crypto_aead_get_flags(aead) & CRYPTO_TFM_NEED_KEY)
142+
ret = -ENOKEY;
143+
else if (req->cryptlen < crypto_aead_authsize(aead))
144+
ret = -EINVAL;
145+
else
146+
ret = alg->decrypt(req);
104147

105-
return crypto_aead_alg(aead)->decrypt(req);
148+
return crypto_aead_errstat(istat, ret);
106149
}
107150
EXPORT_SYMBOL_GPL(crypto_aead_decrypt);
108151

@@ -172,6 +215,26 @@ static void crypto_aead_free_instance(struct crypto_instance *inst)
172215
aead->free(aead);
173216
}
174217

218+
static int __maybe_unused crypto_aead_report_stat(
219+
struct sk_buff *skb, struct crypto_alg *alg)
220+
{
221+
struct aead_alg *aead = container_of(alg, struct aead_alg, base);
222+
struct crypto_istat_aead *istat = aead_get_stat(aead);
223+
struct crypto_stat_aead raead;
224+
225+
memset(&raead, 0, sizeof(raead));
226+
227+
strscpy(raead.type, "aead", sizeof(raead.type));
228+
229+
raead.stat_encrypt_cnt = atomic64_read(&istat->encrypt_cnt);
230+
raead.stat_encrypt_tlen = atomic64_read(&istat->encrypt_tlen);
231+
raead.stat_decrypt_cnt = atomic64_read(&istat->decrypt_cnt);
232+
raead.stat_decrypt_tlen = atomic64_read(&istat->decrypt_tlen);
233+
raead.stat_err_cnt = atomic64_read(&istat->err_cnt);
234+
235+
return nla_put(skb, CRYPTOCFGA_STAT_AEAD, sizeof(raead), &raead);
236+
}
237+
175238
static const struct crypto_type crypto_aead_type = {
176239
.extsize = crypto_alg_extsize,
177240
.init_tfm = crypto_aead_init_tfm,
@@ -181,6 +244,9 @@ static const struct crypto_type crypto_aead_type = {
181244
#endif
182245
#if IS_ENABLED(CONFIG_CRYPTO_USER)
183246
.report = crypto_aead_report,
247+
#endif
248+
#ifdef CONFIG_CRYPTO_STATS
249+
.report_stat = crypto_aead_report_stat,
184250
#endif
185251
.maskclear = ~CRYPTO_ALG_TYPE_MASK,
186252
.maskset = CRYPTO_ALG_TYPE_MASK,
@@ -211,6 +277,7 @@ EXPORT_SYMBOL_GPL(crypto_has_aead);
211277

212278
static int aead_prepare_alg(struct aead_alg *alg)
213279
{
280+
struct crypto_istat_aead *istat = aead_get_stat(alg);
214281
struct crypto_alg *base = &alg->base;
215282

216283
if (max3(alg->maxauthsize, alg->ivsize, alg->chunksize) >
@@ -224,6 +291,9 @@ static int aead_prepare_alg(struct aead_alg *alg)
224291
base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
225292
base->cra_flags |= CRYPTO_ALG_TYPE_AEAD;
226293

294+
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
295+
memset(istat, 0, sizeof(*istat));
296+
227297
return 0;
228298
}
229299

‎crypto/ahash.c‎

Lines changed: 58 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,22 @@
2727

2828
#define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000e
2929

30+
static inline struct crypto_istat_hash *ahash_get_stat(struct ahash_alg *alg)
31+
{
32+
return hash_get_stat(&alg->halg);
33+
}
34+
35+
static inline int crypto_ahash_errstat(struct ahash_alg *alg, int err)
36+
{
37+
if (!IS_ENABLED(CONFIG_CRYPTO_STATS))
38+
return err;
39+
40+
if (err && err != -EINPROGRESS && err != -EBUSY)
41+
atomic64_inc(&ahash_get_stat(alg)->err_cnt);
42+
43+
return err;
44+
}
45+
3046
/*
3147
* For an ahash tfm that is using an shash algorithm (instead of an ahash
3248
* algorithm), this returns the underlying shash tfm.
@@ -328,47 +344,75 @@ static void ahash_restore_req(struct ahash_request *req, int err)
328344
int crypto_ahash_update(struct ahash_request *req)
329345
{
330346
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
347+
struct ahash_alg *alg;
331348

332349
if (likely(tfm->using_shash))
333350
return shash_ahash_update(req, ahash_request_ctx(req));
334351

335-
return crypto_ahash_alg(tfm)->update(req);
352+
alg = crypto_ahash_alg(tfm);
353+
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
354+
atomic64_add(req->nbytes, &ahash_get_stat(alg)->hash_tlen);
355+
return crypto_ahash_errstat(alg, alg->update(req));
336356
}
337357
EXPORT_SYMBOL_GPL(crypto_ahash_update);
338358

339359
int crypto_ahash_final(struct ahash_request *req)
340360
{
341361
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
362+
struct ahash_alg *alg;
342363

343364
if (likely(tfm->using_shash))
344365
return crypto_shash_final(ahash_request_ctx(req), req->result);
345366

346-
return crypto_ahash_alg(tfm)->final(req);
367+
alg = crypto_ahash_alg(tfm);
368+
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
369+
atomic64_inc(&ahash_get_stat(alg)->hash_cnt);
370+
return crypto_ahash_errstat(alg, alg->final(req));
347371
}
348372
EXPORT_SYMBOL_GPL(crypto_ahash_final);
349373

350374
int crypto_ahash_finup(struct ahash_request *req)
351375
{
352376
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
377+
struct ahash_alg *alg;
353378

354379
if (likely(tfm->using_shash))
355380
return shash_ahash_finup(req, ahash_request_ctx(req));
356381

357-
return crypto_ahash_alg(tfm)->finup(req);
382+
alg = crypto_ahash_alg(tfm);
383+
if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
384+
struct crypto_istat_hash *istat = ahash_get_stat(alg);
385+
386+
atomic64_inc(&istat->hash_cnt);
387+
atomic64_add(req->nbytes, &istat->hash_tlen);
388+
}
389+
return crypto_ahash_errstat(alg, alg->finup(req));
358390
}
359391
EXPORT_SYMBOL_GPL(crypto_ahash_finup);
360392

361393
int crypto_ahash_digest(struct ahash_request *req)
362394
{
363395
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
396+
struct ahash_alg *alg;
397+
int err;
364398

365399
if (likely(tfm->using_shash))
366400
return shash_ahash_digest(req, prepare_shash_desc(req, tfm));
367401

402+
alg = crypto_ahash_alg(tfm);
403+
if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
404+
struct crypto_istat_hash *istat = ahash_get_stat(alg);
405+
406+
atomic64_inc(&istat->hash_cnt);
407+
atomic64_add(req->nbytes, &istat->hash_tlen);
408+
}
409+
368410
if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
369-
return -ENOKEY;
411+
err = -ENOKEY;
412+
else
413+
err = alg->digest(req);
370414

371-
return crypto_ahash_alg(tfm)->digest(req);
415+
return crypto_ahash_errstat(alg, err);
372416
}
373417
EXPORT_SYMBOL_GPL(crypto_ahash_digest);
374418

@@ -527,6 +571,12 @@ static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
527571
__crypto_hash_alg_common(alg)->digestsize);
528572
}
529573

574+
static int __maybe_unused crypto_ahash_report_stat(
575+
struct sk_buff *skb, struct crypto_alg *alg)
576+
{
577+
return crypto_hash_report_stat(skb, alg, "ahash");
578+
}
579+
530580
static const struct crypto_type crypto_ahash_type = {
531581
.extsize = crypto_ahash_extsize,
532582
.init_tfm = crypto_ahash_init_tfm,
@@ -536,6 +586,9 @@ static const struct crypto_type crypto_ahash_type = {
536586
#endif
537587
#if IS_ENABLED(CONFIG_CRYPTO_USER)
538588
.report = crypto_ahash_report,
589+
#endif
590+
#ifdef CONFIG_CRYPTO_STATS
591+
.report_stat = crypto_ahash_report_stat,
539592
#endif
540593
.maskclear = ~CRYPTO_ALG_TYPE_MASK,
541594
.maskset = CRYPTO_ALG_TYPE_AHASH_MASK,

0 commit comments

Comments
 (0)