crypto: testmgr - Hide ENOENT errors

When a crypto algorithm with a higher priority is registered, it
kills the spawns of all lower-priority algorithms.  Thus it is to
be expected for an algorithm to go away at any time, even during
a self-test.  This is now much more common with asynchronous testing.

Remove the printk when an ENOENT is encountered during a self-test.
This is not really an error since the algorithm being tested is no
longer there (i.e., it didn't fail the test which is what we care
about).

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/crypto/testmgr.c b/crypto/testmgr.c
index f02cb07..ee8da62 100644 (file)
--- a/crypto/testmgr.c
+++ b/crypto/testmgr.c
@@ -1939,6 +1939,8 @@ static int __alg_test_hash(const struct hash_testvec *vecs,
 
        atfm = crypto_alloc_ahash(driver, type, mask);
        if (IS_ERR(atfm)) {
+               if (PTR_ERR(atfm) == -ENOENT)
+                       return -ENOENT;
                pr_err("alg: hash: failed to allocate transform for %s: %ld\n",
                       driver, PTR_ERR(atfm));
                return PTR_ERR(atfm);
@@ -2703,6 +2705,8 @@ static int alg_test_aead(const struct alg_test_desc *desc, const char *driver,
 
        tfm = crypto_alloc_aead(driver, type, mask);
        if (IS_ERR(tfm)) {
+               if (PTR_ERR(tfm) == -ENOENT)
+                       return -ENOENT;
                pr_err("alg: aead: failed to allocate transform for %s: %ld\n",
                       driver, PTR_ERR(tfm));
                return PTR_ERR(tfm);
@@ -3280,6 +3284,8 @@ static int alg_test_skcipher(const struct alg_test_desc *desc,
 
        tfm = crypto_alloc_skcipher(driver, type, mask);
        if (IS_ERR(tfm)) {
+               if (PTR_ERR(tfm) == -ENOENT)
+                       return -ENOENT;
                pr_err("alg: skcipher: failed to allocate transform for %s: %ld\n",
                       driver, PTR_ERR(tfm));
                return PTR_ERR(tfm);
@@ -3693,6 +3699,8 @@ static int alg_test_cipher(const struct alg_test_desc *desc,
 
        tfm = crypto_alloc_cipher(driver, type, mask);
        if (IS_ERR(tfm)) {
+               if (PTR_ERR(tfm) == -ENOENT)
+                       return -ENOENT;
                printk(KERN_ERR "alg: cipher: Failed to load transform for "
                       "%s: %ld\n", driver, PTR_ERR(tfm));
                return PTR_ERR(tfm);
@@ -3717,6 +3725,8 @@ static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
        if (algo_type == CRYPTO_ALG_TYPE_ACOMPRESS) {
                acomp = crypto_alloc_acomp(driver, type, mask);
                if (IS_ERR(acomp)) {
+                       if (PTR_ERR(acomp) == -ENOENT)
+                               return -ENOENT;
                        pr_err("alg: acomp: Failed to load transform for %s: %ld\n",
                               driver, PTR_ERR(acomp));
                        return PTR_ERR(acomp);
@@ -3729,6 +3739,8 @@ static int alg_test_comp(const struct alg_test_desc *desc, const char *driver,
        } else {
                comp = crypto_alloc_comp(driver, type, mask);
                if (IS_ERR(comp)) {
+                       if (PTR_ERR(comp) == -ENOENT)
+                               return -ENOENT;
                        pr_err("alg: comp: Failed to load transform for %s: %ld\n",
                               driver, PTR_ERR(comp));
                        return PTR_ERR(comp);
@@ -3805,6 +3817,8 @@ static int alg_test_cprng(const struct alg_test_desc *desc, const char *driver,
 
        rng = crypto_alloc_rng(driver, type, mask);
        if (IS_ERR(rng)) {
+               if (PTR_ERR(rng) == -ENOENT)
+                       return -ENOENT;
                printk(KERN_ERR "alg: cprng: Failed to load transform for %s: "
                       "%ld\n", driver, PTR_ERR(rng));
                return PTR_ERR(rng);
@@ -3832,10 +3846,13 @@ static int drbg_cavs_test(const struct drbg_testvec *test, int pr,
 
        drng = crypto_alloc_rng(driver, type, mask);
        if (IS_ERR(drng)) {
+               if (PTR_ERR(drng) == -ENOENT)
+                       goto out_no_rng;
                printk(KERN_ERR "alg: drbg: could not allocate DRNG handle for "
                       "%s\n", driver);
+out_no_rng:
                kfree_sensitive(buf);
-               return -ENOMEM;
+               return PTR_ERR(drng);
        }
 
        test_data.testentropy = &testentropy;
@@ -4077,6 +4094,8 @@ static int alg_test_kpp(const struct alg_test_desc *desc, const char *driver,
 
        tfm = crypto_alloc_kpp(driver, type, mask);
        if (IS_ERR(tfm)) {
+               if (PTR_ERR(tfm) == -ENOENT)
+                       return -ENOENT;
                pr_err("alg: kpp: Failed to load tfm for %s: %ld\n",
                       driver, PTR_ERR(tfm));
                return PTR_ERR(tfm);
@@ -4305,6 +4324,8 @@ static int alg_test_akcipher(const struct alg_test_desc *desc,
 
        tfm = crypto_alloc_akcipher(driver, type, mask);
        if (IS_ERR(tfm)) {
+               if (PTR_ERR(tfm) == -ENOENT)
+                       return -ENOENT;
                pr_err("alg: akcipher: Failed to load tfm for %s: %ld\n",
                       driver, PTR_ERR(tfm));
                return PTR_ERR(tfm);