hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

crypto: tcrypt - Abort and only log if there is an error 

The info printed is a complete waste of space when there is no error
since it doesn't tell us anything that we don't already know.  If there
is an error, we can also be more verbose.

In case that there is an error, this patch also aborts the test and
returns the error to the caller.  In future this will be used to
algorithms at registration time.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Herbert Xu 2008-07-31 14:03:44 +08:00
parent 8cb51ba8e0
commit bdecd22821
1 changed files with 200 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

346
crypto/tcrypt.c
View File

@ -98,8 +98,8 @@ static void tcrypt_complete(struct crypto_async_request *req, int err)
complete(&res->completion); complete(&res->completion);
} }
static void test_hash(char *algo, struct hash_testvec *template, static int test_hash(char *algo, struct hash_testvec *template,
unsigned int tcount) unsigned int tcount)
{ {
unsigned int i, j, k, temp; unsigned int i, j, k, temp;
struct scatterlist sg[8]; struct scatterlist sg[8];
@ -110,27 +110,26 @@ static void test_hash(char *algo, struct hash_testvec *template,
int ret; int ret;
void *hash_buff; void *hash_buff;
printk("\ntesting %s\n", algo);
init_completion(&tresult.completion); init_completion(&tresult.completion);
tfm = crypto_alloc_ahash(algo, 0, 0); tfm = crypto_alloc_ahash(algo, 0, 0);
if (IS_ERR(tfm)) { if (IS_ERR(tfm)) {
printk("failed to load transform for %s: %ld\n", algo, printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
PTR_ERR(tfm)); "%ld\n", algo, PTR_ERR(tfm));
return; return PTR_ERR(tfm);
} }
req = ahash_request_alloc(tfm, GFP_KERNEL); req = ahash_request_alloc(tfm, GFP_KERNEL);
if (!req) { if (!req) {
printk(KERN_ERR "failed to allocate request for %s\n", algo); printk(KERN_ERR "alg: hash: Failed to allocate request for "
"%s\n", algo);
ret = -ENOMEM;
goto out_noreq; goto out_noreq;
} }
ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG, ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
tcrypt_complete, &tresult); tcrypt_complete, &tresult);
for (i = 0; i < tcount; i++) { for (i = 0; i < tcount; i++) {
printk("test %u:\n", i + 1);
memset(result, 0, 64); memset(result, 0, 64);
hash_buff = xbuf[0]; hash_buff = xbuf[0];
@ -143,7 +142,9 @@ static void test_hash(char *algo, struct hash_testvec *template,
ret = crypto_ahash_setkey(tfm, template[i].key, ret = crypto_ahash_setkey(tfm, template[i].key,
template[i].ksize); template[i].ksize);
if (ret) { if (ret) {
printk("setkey() failed ret=%d\n", ret); printk(KERN_ERR "alg: hash: setkey failed on "
"test %d for %s: ret=%d\n", i + 1, algo,
-ret);
goto out; goto out;
} }
} }
@ -163,24 +164,25 @@ static void test_hash(char *algo, struct hash_testvec *template,
} }
/* fall through */ /* fall through */
default: default:
printk("digest () failed ret=%d\n", ret); printk(KERN_ERR "alg: hash: digest failed on test %d "
"for %s: ret=%d\n", i + 1, algo, -ret);
goto out; goto out;
} }
hexdump(result, crypto_ahash_digestsize(tfm)); if (memcmp(result, template[i].digest,
printk("%s\n", crypto_ahash_digestsize(tfm))) {
memcmp(result, template[i].digest, printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
crypto_ahash_digestsize(tfm)) ? i + 1, algo);
"fail" : "pass"); hexdump(result, crypto_ahash_digestsize(tfm));
ret = -EINVAL;
goto out;
}
} }
printk("testing %s across pages\n", algo);
j = 0; j = 0;
for (i = 0; i < tcount; i++) { for (i = 0; i < tcount; i++) {
if (template[i].np) { if (template[i].np) {
j++; j++;
printk("test %u:\n", j);
memset(result, 0, 64); memset(result, 0, 64);
temp = 0; temp = 0;
@ -201,7 +203,10 @@ static void test_hash(char *algo, struct hash_testvec *template,
template[i].ksize); template[i].ksize);
if (ret) { if (ret) {
printk("setkey() failed ret=%d\n", ret); printk(KERN_ERR "alg: hash: setkey "
"failed on chunking test %d "
"for %s: ret=%d\n", j, algo,
-ret);
goto out; goto out;
} }
} }
@ -222,28 +227,37 @@ static void test_hash(char *algo, struct hash_testvec *template,
} }
/* fall through */ /* fall through */
default: default:
printk("digest () failed ret=%d\n", ret); printk(KERN_ERR "alg: hash: digest failed "
"on chunking test %d for %s: "
"ret=%d\n", j, algo, -ret);
goto out; goto out;
} }
hexdump(result, crypto_ahash_digestsize(tfm)); if (memcmp(result, template[i].digest,
printk("%s\n", crypto_ahash_digestsize(tfm))) {
memcmp(result, template[i].digest, printk(KERN_ERR "alg: hash: Chunking test %d "
crypto_ahash_digestsize(tfm)) ? "failed for %s\n", j, algo);
"fail" : "pass"); hexdump(result, crypto_ahash_digestsize(tfm));
ret = -EINVAL;
goto out;
}
} }
} }
ret = 0;
out: out:
ahash_request_free(req); ahash_request_free(req);
out_noreq: out_noreq:
crypto_free_ahash(tfm); crypto_free_ahash(tfm);
return ret;
} }
static void test_aead(char *algo, int enc, struct aead_testvec *template, static int test_aead(char *algo, int enc, struct aead_testvec *template,
unsigned int tcount) unsigned int tcount)
{ {
unsigned int ret, i, j, k, n, temp; unsigned int i, j, k, n, temp;
int ret = 0;
char *q; char *q;
struct crypto_aead *tfm; struct crypto_aead *tfm;
char *key; char *key;
@ -262,21 +276,21 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
else else
e = "decryption"; e = "decryption";
printk(KERN_INFO "\ntesting %s %s\n", algo, e);
init_completion(&result.completion); init_completion(&result.completion);
tfm = crypto_alloc_aead(algo, 0, 0); tfm = crypto_alloc_aead(algo, 0, 0);
if (IS_ERR(tfm)) { if (IS_ERR(tfm)) {
printk(KERN_INFO "failed to load transform for %s: %ld\n", printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
algo, PTR_ERR(tfm)); "%ld\n", algo, PTR_ERR(tfm));
return; return PTR_ERR(tfm);
} }
req = aead_request_alloc(tfm, GFP_KERNEL); req = aead_request_alloc(tfm, GFP_KERNEL);
if (!req) { if (!req) {
printk(KERN_INFO "failed to allocate request for %s\n", algo); printk(KERN_ERR "alg: aead: Failed to allocate request for "
"%s\n", algo);
ret = -ENOMEM;
goto out; goto out;
} }
@ -285,8 +299,7 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
for (i = 0, j = 0; i < tcount; i++) { for (i = 0, j = 0; i < tcount; i++) {
if (!template[i].np) { if (!template[i].np) {
printk(KERN_INFO "test %u (%d bit key):\n", j++;
++j, template[i].klen * 8);
/* some tepmplates have no input data but they will /* some tepmplates have no input data but they will
* touch input * touch input
@ -310,21 +323,21 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
ret = crypto_aead_setkey(tfm, key, ret = crypto_aead_setkey(tfm, key,
template[i].klen); template[i].klen);
if (ret) { if (!ret == template[i].fail) {
printk(KERN_INFO "setkey() failed flags=%x\n", printk(KERN_ERR "alg: aead: setkey failed on "
"test %d for %s: flags=%x\n", j, algo,
crypto_aead_get_flags(tfm)); crypto_aead_get_flags(tfm));
goto out;
if (!template[i].fail) } else if (ret)
continue; continue;
}
authsize = abs(template[i].rlen - template[i].ilen); authsize = abs(template[i].rlen - template[i].ilen);
ret = crypto_aead_setauthsize(tfm, authsize); ret = crypto_aead_setauthsize(tfm, authsize);
if (ret) { if (ret) {
printk(KERN_INFO printk(KERN_ERR "alg: aead: Failed to set "
"failed to set authsize = %u\n", "authsize to %u on test %d for %s\n",
authsize); authsize, j, algo);
continue; goto out;
} }
sg_init_one(&sg[0], input, sg_init_one(&sg[0], input,
@ -354,26 +367,25 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
} }
/* fall through */ /* fall through */
default: default:
printk(KERN_INFO "%s () failed err=%d\n", printk(KERN_ERR "alg: aead: %s failed on test "
e, -ret); "%d for %s: ret=%d\n", e, j, algo, -ret);
continue; goto out;
} }
q = input; q = input;
hexdump(q, template[i].rlen); if (memcmp(q, template[i].result, template[i].rlen)) {
printk(KERN_ERR "alg: aead: Test %d failed on "
printk(KERN_INFO "enc/dec: %s\n", "%s for %s\n", j, e, algo);
memcmp(q, template[i].result, hexdump(q, template[i].rlen);
template[i].rlen) ? "fail" : "pass"); ret = -EINVAL;
goto out;
}
} }
} }
printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e);
for (i = 0, j = 0; i < tcount; i++) { for (i = 0, j = 0; i < tcount; i++) {
if (template[i].np) { if (template[i].np) {
printk(KERN_INFO "test %u (%d bit key):\n", j++;
++j, template[i].klen * 8);
if (template[i].iv) if (template[i].iv)
memcpy(iv, template[i].iv, MAX_IVLEN); memcpy(iv, template[i].iv, MAX_IVLEN);
@ -387,16 +399,17 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
key = template[i].key; key = template[i].key;
ret = crypto_aead_setkey(tfm, key, template[i].klen); ret = crypto_aead_setkey(tfm, key, template[i].klen);
if (ret) { if (!ret == template[i].fail) {
printk(KERN_INFO "setkey() failed flags=%x\n", printk(KERN_ERR "alg: aead: setkey failed on "
crypto_aead_get_flags(tfm)); "chunk test %d for %s: flags=%x\n", j,
algo, crypto_aead_get_flags(tfm));
if (!template[i].fail) goto out;
goto out; } else if (ret)
} continue;
authsize = abs(template[i].rlen - template[i].ilen); authsize = abs(template[i].rlen - template[i].ilen);
ret = -EINVAL;
sg_init_table(sg, template[i].np); sg_init_table(sg, template[i].np);
for (k = 0, temp = 0; k < template[i].np; k++) { for (k = 0, temp = 0; k < template[i].np; k++) {
if (WARN_ON(offset_in_page(IDX[k]) + if (WARN_ON(offset_in_page(IDX[k]) +
@ -421,17 +434,19 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
ret = crypto_aead_setauthsize(tfm, authsize); ret = crypto_aead_setauthsize(tfm, authsize);
if (ret) { if (ret) {
printk(KERN_INFO printk(KERN_ERR "alg: aead: Failed to set "
"failed to set authsize = %u\n", "authsize to %u on chunk test %d for "
authsize); "%s\n", authsize, j, algo);
goto out; goto out;
} }
if (enc) { if (enc) {
if (WARN_ON(sg[k - 1].offset + if (WARN_ON(sg[k - 1].offset +
sg[k - 1].length + authsize > sg[k - 1].length + authsize >
PAGE_SIZE)) PAGE_SIZE)) {
ret = -EINVAL;
goto out; goto out;
}
sg[k - 1].length += authsize; sg[k - 1].length += authsize;
} }
@ -470,23 +485,28 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
} }
/* fall through */ /* fall through */
default: default:
printk(KERN_INFO "%s () failed err=%d\n", printk(KERN_ERR "alg: aead: %s failed on "
e, -ret); "chunk test %d for %s: ret=%d\n", e, j,
algo, -ret);
goto out; goto out;
} }
ret = -EINVAL;
for (k = 0, temp = 0; k < template[i].np; k++) { for (k = 0, temp = 0; k < template[i].np; k++) {
printk(KERN_INFO "page %u\n", k);
q = xbuf[IDX[k] >> PAGE_SHIFT] + q = xbuf[IDX[k] >> PAGE_SHIFT] +
offset_in_page(IDX[k]); offset_in_page(IDX[k]);
n = template[i].tap[k]; n = template[i].tap[k];
if (k == template[i].np - 1) if (k == template[i].np - 1)
n += enc ? authsize : -authsize; n += enc ? authsize : -authsize;
hexdump(q, n);
printk(KERN_INFO "%s\n", if (memcmp(q, template[i].result + temp, n)) {
memcmp(q, template[i].result + temp, n) ? printk(KERN_ERR "alg: aead: Chunk "
"fail" : "pass"); "test %d failed on %s at page "
"%u for %s\n", j, e, k, algo);
hexdump(q, n);
goto out;
}
q += n; q += n;
if (k == template[i].np - 1 && !enc) { if (k == template[i].np - 1 && !enc) {
@ -501,9 +521,13 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
; ;
} }
if (n) { if (n) {
printk("Result buffer corruption %u " printk(KERN_ERR "alg: aead: Result "
"bytes:\n", n); "buffer corruption in chunk "
"test %d on %s at page %u for "
"%s: %u bytes:\n", j, e, k,
algo, n);
hexdump(q, n); hexdump(q, n);
goto out;
} }
temp += template[i].tap[k]; temp += template[i].tap[k];
@ -511,15 +535,19 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
} }
} }
ret = 0;
out: out:
crypto_free_aead(tfm); crypto_free_aead(tfm);
aead_request_free(req); aead_request_free(req);
return ret;
} }
static void test_cipher(char *algo, int enc, static int test_cipher(char *algo, int enc,
struct cipher_testvec *template, unsigned int tcount) struct cipher_testvec *template, unsigned int tcount)
{ {
unsigned int ret, i, j, k, n, temp; unsigned int i, j, k, n, temp;
int ret;
char *q; char *q;
struct crypto_ablkcipher *tfm; struct crypto_ablkcipher *tfm;
struct ablkcipher_request *req; struct ablkcipher_request *req;
@ -534,20 +562,20 @@ static void test_cipher(char *algo, int enc,
else else
e = "decryption"; e = "decryption";
printk("\ntesting %s %s\n", algo, e);
init_completion(&result.completion); init_completion(&result.completion);
tfm = crypto_alloc_ablkcipher(algo, 0, 0); tfm = crypto_alloc_ablkcipher(algo, 0, 0);
if (IS_ERR(tfm)) { if (IS_ERR(tfm)) {
printk("failed to load transform for %s: %ld\n", algo, printk(KERN_ERR "alg: cipher: Failed to load transform for "
PTR_ERR(tfm)); "%s: %ld\n", algo, PTR_ERR(tfm));
return; return PTR_ERR(tfm);
} }
req = ablkcipher_request_alloc(tfm, GFP_KERNEL); req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
if (!req) { if (!req) {
printk("failed to allocate request for %s\n", algo); printk(KERN_ERR "alg: cipher: Failed to allocate request for "
"%s\n", algo);
ret = -ENOMEM;
goto out; goto out;
} }
@ -563,8 +591,6 @@ static void test_cipher(char *algo, int enc,
if (!(template[i].np)) { if (!(template[i].np)) {
j++; j++;
printk("test %u (%d bit key):\n",
j, template[i].klen * 8);
data = xbuf[0]; data = xbuf[0];
memcpy(data, template[i].input, template[i].ilen); memcpy(data, template[i].input, template[i].ilen);
@ -576,13 +602,13 @@ static void test_cipher(char *algo, int enc,
ret = crypto_ablkcipher_setkey(tfm, template[i].key, ret = crypto_ablkcipher_setkey(tfm, template[i].key,
template[i].klen); template[i].klen);
if (ret) { if (!ret == template[i].fail) {
printk("setkey() failed flags=%x\n", printk(KERN_ERR "alg: cipher: setkey failed "
crypto_ablkcipher_get_flags(tfm)); "on test %d for %s: flags=%x\n", j,
algo, crypto_ablkcipher_get_flags(tfm));
if (!template[i].fail) goto out;
goto out; } else if (ret)
} continue;
sg_init_one(&sg[0], data, template[i].ilen); sg_init_one(&sg[0], data, template[i].ilen);
@ -605,21 +631,23 @@ static void test_cipher(char *algo, int enc,
} }
/* fall through */ /* fall through */
default: default:
printk("%s () failed err=%d\n", e, -ret); printk(KERN_ERR "alg: cipher: %s failed on "
"test %d for %s: ret=%d\n", e, j, algo,
-ret);
goto out; goto out;
} }
q = data; q = data;
hexdump(q, template[i].rlen); if (memcmp(q, template[i].result, template[i].rlen)) {
printk(KERN_ERR "alg: cipher: Test %d failed "
printk("%s\n", "on %s for %s\n", j, e, algo);
memcmp(q, template[i].result, hexdump(q, template[i].rlen);
template[i].rlen) ? "fail" : "pass"); ret = -EINVAL;
goto out;
}
} }
} }
printk("\ntesting %s %s across pages (chunking)\n", algo, e);
j = 0; j = 0;
for (i = 0; i < tcount; i++) { for (i = 0; i < tcount; i++) {
@ -630,8 +658,6 @@ static void test_cipher(char *algo, int enc,
if (template[i].np) { if (template[i].np) {
j++; j++;
printk("test %u (%d bit key):\n",
j, template[i].klen * 8);
crypto_ablkcipher_clear_flags(tfm, ~0); crypto_ablkcipher_clear_flags(tfm, ~0);
if (template[i].wk) if (template[i].wk)
@ -640,15 +666,17 @@ static void test_cipher(char *algo, int enc,
ret = crypto_ablkcipher_setkey(tfm, template[i].key, ret = crypto_ablkcipher_setkey(tfm, template[i].key,
template[i].klen); template[i].klen);
if (ret) { if (!ret == template[i].fail) {
printk("setkey() failed flags=%x\n", printk(KERN_ERR "alg: cipher: setkey failed "
crypto_ablkcipher_get_flags(tfm)); "on chunk test %d for %s: flags=%x\n",
j, algo,
if (!template[i].fail) crypto_ablkcipher_get_flags(tfm));
goto out; goto out;
} } else if (ret)
continue;
temp = 0; temp = 0;
ret = -EINVAL;
sg_init_table(sg, template[i].np); sg_init_table(sg, template[i].np);
for (k = 0; k < template[i].np; k++) { for (k = 0; k < template[i].np; k++) {
if (WARN_ON(offset_in_page(IDX[k]) + if (WARN_ON(offset_in_page(IDX[k]) +
@ -690,36 +718,50 @@ static void test_cipher(char *algo, int enc,
} }
/* fall through */ /* fall through */
default: default:
printk("%s () failed err=%d\n", e, -ret); printk(KERN_ERR "alg: cipher: %s failed on "
"chunk test %d for %s: ret=%d\n", e, j,
algo, -ret);
goto out; goto out;
} }
temp = 0; temp = 0;
ret = -EINVAL;
for (k = 0; k < template[i].np; k++) { for (k = 0; k < template[i].np; k++) {
printk("page %u\n", k);
q = xbuf[IDX[k] >> PAGE_SHIFT] + q = xbuf[IDX[k] >> PAGE_SHIFT] +
offset_in_page(IDX[k]); offset_in_page(IDX[k]);
hexdump(q, template[i].tap[k]);
printk("%s\n", if (memcmp(q, template[i].result + temp,
memcmp(q, template[i].result + temp, template[i].tap[k])) {
template[i].tap[k]) ? "fail" : printk(KERN_ERR "alg: cipher: Chunk "
"pass"); "test %d failed on %s at page "
"%u for %s\n", j, e, k, algo);
hexdump(q, template[i].tap[k]);
goto out;
}
q += template[i].tap[k]; q += template[i].tap[k];
for (n = 0; offset_in_page(q + n) && q[n]; n++) for (n = 0; offset_in_page(q + n) && q[n]; n++)
; ;
if (n) { if (n) {
printk("Result buffer corruption %u " printk(KERN_ERR "alg: cipher: "
"bytes:\n", n); "Result buffer corruption in "
"chunk test %d on %s at page "
"%u for %s: %u bytes:\n", j, e,
k, algo, n);
hexdump(q, n); hexdump(q, n);
goto out;
} }
temp += template[i].tap[k]; temp += template[i].tap[k];
} }
} }
} }
ret = 0;
out: out:
crypto_free_ablkcipher(tfm); crypto_free_ablkcipher(tfm);
ablkcipher_request_free(req); ablkcipher_request_free(req);
return ret;
} }
static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc, static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
@ -1118,62 +1160,74 @@ out:
crypto_free_hash(tfm); crypto_free_hash(tfm);
} }
static void test_comp(char *algo, struct comp_testvec *ctemplate, static int test_comp(char *algo, struct comp_testvec *ctemplate,
struct comp_testvec *dtemplate, int ctcount, int dtcount) struct comp_testvec *dtemplate, int ctcount, int dtcount)
{ {
unsigned int i; unsigned int i;
char result[COMP_BUF_SIZE]; char result[COMP_BUF_SIZE];
struct crypto_comp *tfm; struct crypto_comp *tfm;
int ret;
printk("\ntesting %s compression\n", algo);
tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC); tfm = crypto_alloc_comp(algo, 0, CRYPTO_ALG_ASYNC);
if (IS_ERR(tfm)) { if (IS_ERR(tfm)) {
printk("failed to load transform for %s\n", algo); printk(KERN_ERR "alg: comp: Failed to load transform for %s: "
return; "%ld\n", algo, PTR_ERR(tfm));
return PTR_ERR(tfm);
} }
for (i = 0; i < ctcount; i++) { for (i = 0; i < ctcount; i++) {
int ilen, ret, dlen = COMP_BUF_SIZE; int ilen, dlen = COMP_BUF_SIZE;
printk("test %u:\n", i + 1);
memset(result, 0, sizeof (result)); memset(result, 0, sizeof (result));
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, result, &dlen);
if (ret) { if (ret) {
printk("fail: ret=%d\n", ret); printk(KERN_ERR "alg: comp: compression failed "
continue; "on test %d for %s: ret=%d\n", i + 1, algo,
-ret);
goto out;
} }
hexdump(result, dlen);
printk("%s (ratio %d:%d)\n",
memcmp(result, ctemplate[i].output, dlen) ? "fail" : "pass",
ilen, dlen);
}
printk("\ntesting %s decompression\n", algo); if (memcmp(result, ctemplate[i].output, dlen)) {
printk(KERN_ERR "alg: comp: Compression test %d "
"failed for %s\n", i + 1, algo);
hexdump(result, dlen);
ret = -EINVAL;
goto out;
}
}
for (i = 0; i < dtcount; i++) { for (i = 0; i < dtcount; i++) {
int ilen, ret, dlen = COMP_BUF_SIZE; int ilen, ret, dlen = COMP_BUF_SIZE;
printk("test %u:\n", i + 1);
memset(result, 0, sizeof (result)); memset(result, 0, sizeof (result));
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, result, &dlen);
if (ret) { if (ret) {
printk("fail: ret=%d\n", ret); printk(KERN_ERR "alg: comp: decompression failed "
continue; "on test %d for %s: ret=%d\n", i + 1, algo,
-ret);
goto out;
}
if (memcmp(result, dtemplate[i].output, dlen)) {
printk(KERN_ERR "alg: comp: Decompression test %d "
"failed for %s\n", i + 1, algo);
hexdump(result, dlen);
ret = -EINVAL;
goto out;
} }
hexdump(result, dlen);
printk("%s (ratio %d:%d)\n",
memcmp(result, dtemplate[i].output, dlen) ? "fail" : "pass",
ilen, dlen);
} }
ret = 0;
out:
crypto_free_comp(tfm); crypto_free_comp(tfm);
return ret;
} }
static void test_available(void) static void test_available(void)