redonkable
/
remarkable-linux
1
0
Fork 0
Code Releases Activity

crypto: testmgr - Allow different compression results 

The following error is triggered by the ThunderX ZIP driver
if the testmanager is enabled:

[  199.069437] ThunderX-ZIP 0000:03:00.0: Found ZIP device 0 177d:a01a on Node 0
[  199.073573] alg: comp: Compression test 1 failed for deflate-generic: output len = 37

The reason for this error is the verification of the compression
results. Verifying the compression result only works if all
algorithm parameters are identical, in this case to the software
implementation.

Different compression engines like the ThunderX ZIP coprocessor
might yield different compression results by tuning the
algorithm parameters. In our case the compressed result is
shorter than the test vector.

We should not forbid different compression results but only
check that compression -> decompression yields the same
result. This is done already in the acomp test. Do something
similar for test_comp().

Signed-off-by: Mahipal Challa <mchalla@cavium.com>
Signed-off-by: Balakrishna Bhamidipati <bbhamidipati@cavium.com>
[jglauber@cavium.com: removed unrelated printk changes, rewrote commit msg,
 fixed whitespace and unneeded initialization]
Signed-off-by: Jan Glauber <jglauber@cavium.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
zero-colors
Mahipal Challa 2018-04-11 20:28:32 +02:00 committed by Herbert Xu
parent 654f2b937b
commit 336073840a
1 changed files with 37 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
crypto/testmgr.c
View File

@ -1342,19 +1342,30 @@ static int test_comp(struct crypto_comp *tfm,
int ctcount, int dtcount) int ctcount, int dtcount)
{ {
const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm)); const char *algo = crypto_tfm_alg_driver_name(crypto_comp_tfm(tfm));
char *output, *decomp_output;
unsigned int i; unsigned int i;
char result[COMP_BUF_SIZE];
int ret; int ret;
output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
if (!output)
return -ENOMEM;
decomp_output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
if (!decomp_output) {
kfree(output);
return -ENOMEM;
}
for (i = 0; i < ctcount; i++) { for (i = 0; i < ctcount; i++) {
int ilen; int ilen;
unsigned int dlen = COMP_BUF_SIZE; unsigned int dlen = COMP_BUF_SIZE;
memset(result, 0, sizeof (result)); memset(output, 0, sizeof(COMP_BUF_SIZE));
memset(decomp_output, 0, sizeof(COMP_BUF_SIZE));
ilen = ctemplate[i].inlen; ilen = ctemplate[i].inlen;
ret = crypto_comp_compress(tfm, ctemplate[i].input, ret = crypto_comp_compress(tfm, ctemplate[i].input,
ilen, result, &dlen); ilen, output, &dlen);
if (ret) { if (ret) {
printk(KERN_ERR "alg: comp: compression failed " printk(KERN_ERR "alg: comp: compression failed "
"on test %d for %s: ret=%d\n", i + 1, algo, "on test %d for %s: ret=%d\n", i + 1, algo,
@ -1362,7 +1373,17 @@ static int test_comp(struct crypto_comp *tfm,
goto out; goto out;
} }
if (dlen != ctemplate[i].outlen) { ilen = dlen;
dlen = COMP_BUF_SIZE;
ret = crypto_comp_decompress(tfm, output,
ilen, decomp_output, &dlen);
if (ret) {
pr_err("alg: comp: compression failed: decompress: on test %d for %s failed: ret=%d\n",
i + 1, algo, -ret);
goto out;
}
if (dlen != ctemplate[i].inlen) {
printk(KERN_ERR "alg: comp: Compression test %d " printk(KERN_ERR "alg: comp: Compression test %d "
"failed for %s: output len = %d\n", i + 1, algo, "failed for %s: output len = %d\n", i + 1, algo,
dlen); dlen);
@ -1370,10 +1391,11 @@ static int test_comp(struct crypto_comp *tfm,
goto out; goto out;
} }
if (memcmp(result, ctemplate[i].output, dlen)) { if (memcmp(decomp_output, ctemplate[i].input,
printk(KERN_ERR "alg: comp: Compression test %d " ctemplate[i].inlen)) {
"failed for %s\n", i + 1, algo); pr_err("alg: comp: compression failed: output differs: on test %d for %s\n",
hexdump(result, dlen); i + 1, algo);
hexdump(decomp_output, dlen);
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
@ -1383,11 +1405,11 @@ static int test_comp(struct crypto_comp *tfm,
int ilen; int ilen;
unsigned int dlen = COMP_BUF_SIZE; unsigned int dlen = COMP_BUF_SIZE;
memset(result, 0, sizeof (result)); memset(decomp_output, 0, sizeof(COMP_BUF_SIZE));
ilen = dtemplate[i].inlen; ilen = dtemplate[i].inlen;
ret = crypto_comp_decompress(tfm, dtemplate[i].input, ret = crypto_comp_decompress(tfm, dtemplate[i].input,
ilen, result, &dlen); ilen, decomp_output, &dlen);
if (ret) { if (ret) {
printk(KERN_ERR "alg: comp: decompression failed " printk(KERN_ERR "alg: comp: decompression failed "
"on test %d for %s: ret=%d\n", i + 1, algo, "on test %d for %s: ret=%d\n", i + 1, algo,
@ -1403,10 +1425,10 @@ static int test_comp(struct crypto_comp *tfm,
goto out; goto out;
} }
if (memcmp(result, dtemplate[i].output, dlen)) { if (memcmp(decomp_output, dtemplate[i].output, dlen)) {
printk(KERN_ERR "alg: comp: Decompression test %d " printk(KERN_ERR "alg: comp: Decompression test %d "
"failed for %s\n", i + 1, algo); "failed for %s\n", i + 1, algo);
hexdump(result, dlen); hexdump(decomp_output, dlen);
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
@ -1415,11 +1437,13 @@ static int test_comp(struct crypto_comp *tfm,
ret = 0; ret = 0;
out: out:
kfree(decomp_output);
kfree(output);
return ret; return ret;
} }
static int test_acomp(struct crypto_acomp *tfm, static int test_acomp(struct crypto_acomp *tfm,
const struct comp_testvec *ctemplate, const struct comp_testvec *ctemplate,
const struct comp_testvec *dtemplate, const struct comp_testvec *dtemplate,
int ctcount, int dtcount) int ctcount, int dtcount)
{ {