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>

1 files changed, 200 insertions, 146 deletions

diff --git a/crypto/tcrypt.c b/crypto/tcrypt.c
index b6d4b5ce00a3..97ec2bdfcce0 100644
--- a/crypto/tcrypt.c
+++ b/crypto/tcrypt.c
@@ -98,8 +98,8 @@ static void tcrypt_complete(struct crypto_async_request *req, int err)
         complete(&res->completion);
 }
 
-static void test_hash(char *algo, struct hash_testvec *template,
-                      unsigned int tcount)
+static int test_hash(char *algo, struct hash_testvec *template,
+                     unsigned int tcount)
 {
         unsigned int i, j, k, temp;
         struct scatterlist sg[8];
@@ -110,27 +110,26 @@ static void test_hash(char *algo, struct hash_testvec *template,
         int ret;
         void *hash_buff;
 
-        printk("\ntesting %s\n", algo);
-
         init_completion(&tresult.completion);
 
         tfm = crypto_alloc_ahash(algo, 0, 0);
         if (IS_ERR(tfm)) {
-                printk("failed to load transform for %s: %ld\n", algo,
-                       PTR_ERR(tfm));
-                return;
+                printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
+                       "%ld\n", algo, PTR_ERR(tfm));
+                return PTR_ERR(tfm);
         }
 
         req = ahash_request_alloc(tfm, GFP_KERNEL);
         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;
         }
         ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
                                    tcrypt_complete, &tresult);
 
         for (i = 0; i < tcount; i++) {
-                printk("test %u:\n", i + 1);
                 memset(result, 0, 64);
 
                 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,
                                                   template[i].ksize);
                         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;
                         }
                 }
@@ -163,24 +164,25 @@ static void test_hash(char *algo, struct hash_testvec *template,
                         }
                         /* fall through */
                 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;
                 }
 
-                hexdump(result, crypto_ahash_digestsize(tfm));
-                printk("%s\n",
-                       memcmp(result, template[i].digest,
-                              crypto_ahash_digestsize(tfm)) ?
-                       "fail" : "pass");
+                if (memcmp(result, template[i].digest,
+                           crypto_ahash_digestsize(tfm))) {
+                        printk(KERN_ERR "alg: hash: Test %d failed for %s\n",
+                               i + 1, algo);
+                        hexdump(result, crypto_ahash_digestsize(tfm));
+                        ret = -EINVAL;
+                        goto out;
+                }
         }
 
-        printk("testing %s across pages\n", algo);
-
         j = 0;
         for (i = 0; i < tcount; i++) {
                 if (template[i].np) {
                         j++;
-                        printk("test %u:\n", j);
                         memset(result, 0, 64);
 
                         temp = 0;
@@ -201,7 +203,10 @@ static void test_hash(char *algo, struct hash_testvec *template,
                                                           template[i].ksize);
 
                                 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;
                                 }
                         }
@@ -222,28 +227,37 @@ static void test_hash(char *algo, struct hash_testvec *template,
                                 }
                                 /* fall through */
                         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;
                         }
 
-                        hexdump(result, crypto_ahash_digestsize(tfm));
-                        printk("%s\n",
-                               memcmp(result, template[i].digest,
-                                      crypto_ahash_digestsize(tfm)) ?
-                               "fail" : "pass");
+                        if (memcmp(result, template[i].digest,
+                                   crypto_ahash_digestsize(tfm))) {
+                                printk(KERN_ERR "alg: hash: Chunking test %d "
+                                       "failed for %s\n", j, algo);
+                                hexdump(result, crypto_ahash_digestsize(tfm));
+                                ret = -EINVAL;
+                                goto out;
+                        }
                 }
         }
 
+        ret = 0;
+
 out:
         ahash_request_free(req);
 out_noreq:
         crypto_free_ahash(tfm);
+        return ret;
 }
 
-static void test_aead(char *algo, int enc, struct aead_testvec *template,
-                      unsigned int tcount)
+static int test_aead(char *algo, int enc, struct aead_testvec *template,
+                     unsigned int tcount)
 {
-        unsigned int ret, i, j, k, n, temp;
+        unsigned int i, j, k, n, temp;
+        int ret = 0;
         char *q;
         struct crypto_aead *tfm;
         char *key;
@@ -262,21 +276,21 @@ static void test_aead(char *algo, int enc, struct aead_testvec *template,
         else
                 e = "decryption";
 
-        printk(KERN_INFO "\ntesting %s %s\n", algo, e);
-
         init_completion(&result.completion);
 
         tfm = crypto_alloc_aead(algo, 0, 0);
 
         if (IS_ERR(tfm)) {
-                printk(KERN_INFO "failed to load transform for %s: %ld\n",
-                       algo, PTR_ERR(tfm));
-                return;
+                printk(KERN_ERR "alg: aead: Failed to load transform for %s: "
+                       "%ld\n", algo, PTR_ERR(tfm));
+                return PTR_ERR(tfm);
         }