crypto: Resolve shadow warnings

Change formal parameters to not clash with global names to
eliminate many W=2 warnings.

Signed-off-by: Mark Rustad <mark.d.rustad@intel.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

1 files changed, 39 insertions, 38 deletions

diff --git a/crypto/tcrypt.c b/crypto/tcrypt.c
index c48d07857a2b..890449e6e7ef 100644
--- a/crypto/tcrypt.c
+++ b/crypto/tcrypt.c
@@ -73,13 +73,13 @@ static char *check[] = {
 };
 
 static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
-                               struct scatterlist *sg, int blen, int sec)
+                               struct scatterlist *sg, int blen, int secs)
 {
         unsigned long start, end;
         int bcount;
         int ret;
 
-        for (start = jiffies, end = start + sec * HZ, bcount = 0;
+        for (start = jiffies, end = start + secs * HZ, bcount = 0;
              time_before(jiffies, end); bcount++) {
                 if (enc)
                         ret = crypto_blkcipher_encrypt(desc, sg, sg, blen);
@@ -91,7 +91,7 @@ static int test_cipher_jiffies(struct blkcipher_desc *desc, int enc,
         }
 
         printk("%d operations in %d seconds (%ld bytes)\n",
-               bcount, sec, (long)bcount * blen);
+               bcount, secs, (long)bcount * blen);
         return 0;
 }
 
@@ -143,13 +143,13 @@ out:
 }
 
 static int test_aead_jiffies(struct aead_request *req, int enc,
-                                int blen, int sec)
+                                int blen, int secs)
 {
         unsigned long start, end;
         int bcount;
         int ret;
 
-        for (start = jiffies, end = start + sec * HZ, bcount = 0;
+        for (start = jiffies, end = start + secs * HZ, bcount = 0;
              time_before(jiffies, end); bcount++) {
                 if (enc)
                         ret = crypto_aead_encrypt(req);
@@ -161,7 +161,7 @@ static int test_aead_jiffies(struct aead_request *req, int enc,
         }
 
         printk("%d operations in %d seconds (%ld bytes)\n",
-               bcount, sec, (long)bcount * blen);
+               bcount, secs, (long)bcount * blen);
         return 0;
 }
 
@@ -265,7 +265,7 @@ static void sg_init_aead(struct scatterlist *sg, char *xbuf[XBUFSIZE],
         }
 }
 
-static void test_aead_speed(const char *algo, int enc, unsigned int sec,
+static void test_aead_speed(const char *algo, int enc, unsigned int secs,
                             struct aead_speed_template *template,
                             unsigned int tcount, u8 authsize,
                             unsigned int aad_size, u8 *keysize)
@@ -379,8 +379,9 @@ static void test_aead_speed(const char *algo, int enc, unsigned int sec,
                         aead_request_set_crypt(req, sg, sgout, *b_size, iv);
                         aead_request_set_assoc(req, asg, aad_size);
 
-                        if (sec)
-                                ret = test_aead_jiffies(req, enc, *b_size, sec);
+                        if (secs)
+                                ret = test_aead_jiffies(req, enc, *b_size,
+                                                        secs);
                         else
                                 ret = test_aead_cycles(req, enc, *b_size);
 
@@ -410,7 +411,7 @@ out_noxbuf:
         return;
 }
 
-static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
+static void test_cipher_speed(const char *algo, int enc, unsigned int secs,
                               struct cipher_speed_template *template,
                               unsigned int tcount, u8 *keysize)
 {
@@ -489,9 +490,9 @@ static void test_cipher_speed(const char *algo, int enc, unsigned int sec,
                                 crypto_blkcipher_set_iv(tfm, iv, iv_len);
                         }
 
-                        if (sec)
+                        if (secs)
                                 ret = test_cipher_jiffies(&desc, enc, sg,
-                                                          *b_size, sec);
+                                                          *b_size, secs);
                         else
                                 ret = test_cipher_cycles(&desc, enc, sg,
                                                          *b_size);
@@ -512,13 +513,13 @@ out:
 
 static int test_hash_jiffies_digest(struct hash_desc *desc,
                                     struct scatterlist *sg, int blen,
-                                    char *out, int sec)
+                                    char *out, int secs)
 {
         unsigned long start, end;
         int bcount;
         int ret;
 
-        for (start = jiffies, end = start + sec * HZ, bcount = 0;
+        for (start = jiffies, end = start + secs * HZ, bcount = 0;
              time_before(jiffies, end); bcount++) {
                 ret = crypto_hash_digest(desc, sg, blen, out);
                 if (ret)
@@ -526,22 +527,22 @@ static int test_hash_jiffies_digest(struct hash_desc *desc,
         }
 
         printk("%6u opers/sec, %9lu bytes/sec\n",
-               bcount / sec, ((long)bcount * blen) / sec);
+               bcount / secs, ((long)bcount * blen) / secs);
 
         return 0;
 }
 
 static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
-                             int blen, int plen, char *out, int sec)
+                             int blen, int plen, char *out, int secs)
 {
         unsigned long start, end;
         int bcount, pcount;
         int ret;
 
         if (plen == blen)
-                return test_hash_jiffies_digest(desc, sg, blen, out, sec);
+                return test_hash_jiffies_digest(desc, sg, blen, out, secs);
 
-        for (start = jiffies, end = start + sec * HZ, bcount = 0;
+        for (start = jiffies, end = start + secs * HZ, bcount = 0;
              time_before(jiffies, end); bcount++) {
                 ret = crypto_hash_init(desc);
                 if (ret)
@@ -558,7 +559,7 @@ static int test_hash_jiffies(struct hash_desc *desc, struct scatterlist *sg,
         }
 
         printk("%6u opers/sec, %9lu bytes/sec\n",
-               bcount / sec, ((long)bcount * blen) / sec);
+               bcount / secs, ((long)bcount * blen) / secs);
 
         return 0;
 }
@@ -679,7 +680,7 @@ static void test_hash_sg_init(struct scatterlist *sg)
         }
 }
 
-static void test_hash_speed(const char *algo, unsigned int sec,
+static void test_hash_speed(const char *algo, unsigned int secs,
                             struct hash_speed *speed)
 {
         struct scatterlist sg[TVMEMSIZE];
@@ -725,9 +726,9 @@ static void test_hash_speed(const char *algo, unsigned int sec,
                        "(%5u byte blocks,%5u bytes per update,%4u updates): ",
                        i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
 
-                if (sec)
+                if (secs)
                         ret = test_hash_jiffies(&desc, sg, speed[i].blen,
-                                                speed[i].plen, output, sec);
+                                                speed[i].plen, output, secs);
                 else
                         ret = test_hash_cycles(&desc, sg, speed[i].blen,
                                                speed[i].plen, output);
@@ -772,13 +773,13 @@ static inline int do_one_ahash_op(struct ahash_request *req, int ret)
 }
 
 static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
-                                     char *out, int sec)
+                                     char *out, int secs)
 {
         unsigned long start, end;
         int bcount;
         int ret;
 
-        for (start = jiffies, end = start + sec * HZ, bcount = 0;
+        for (start = jiffies, end = start + secs * HZ, bcount = 0;
              time_before(jiffies, end); bcount++) {
                 ret = do_one_ahash_op(req, crypto_ahash_digest(req));
                 if (ret)
@@ -786,22 +787,22 @@ static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,
         }
 
         printk("%6u opers/sec, %9lu bytes/sec\n",
-               bcount / sec, ((long)bcount * blen) / sec);
+               bcount / secs, ((long)bcount * blen) / secs);
 
         return 0;
 }
 
 static int test_ahash_jiffies(struct ahash_request *req, int blen,
-                              int plen, char *out, int sec)
+                              int plen, char *out, int secs)
 {
         unsigned long start, end;
         int bcount, pcount;
         int ret;
 
         if (plen == blen)
-                return test_ahash_jiffies_digest(req, blen, out, sec);
+                return test_ahash_jiffies_digest(req, blen, out, secs);
 
-        for (start = jiffies, end = start + sec * HZ, bcount = 0;
+        for (start = jiffies, end = start + secs * HZ, bcount = 0;
              time_before(jiffies, end); bcount++) {
                 ret = crypto_ahash_init(req);
                 if (ret)
@@ -818,7 +819,7 @@ static int test_ahash_jiffies(struct ahash_request *req, int blen,
         }
 
         pr_cont("%6u opers/sec, %9lu bytes/sec\n",
-                bcount / sec, ((long)bcount * blen) / sec);
+                bcount / secs, ((long)bcount * blen) / secs);
 
         return 0;
 }
@@ -918,7 +919,7 @@ out:
         return 0;
 }
 
-static void test_ahash_speed(const char *algo, unsigned int sec,
+static void test_ahash_speed(const char *algo, unsigned int secs,
                              struct hash_speed *speed)
 {
         struct scatterlist sg[TVMEMSIZE];
@@ -968,9 +969,9 @@ static void test_ahash_speed(const char *algo, unsigned int sec,
 
                 ahash_request_set_crypt(req, sg, output, speed[i].plen);
 
-                if (sec)
+                if (secs)
                         ret = test_ahash_jiffies(req, speed[i].blen,
-                                                 speed[i].plen, output, sec);
+                                                 speed[i].plen, output, secs);
                 else
                         ret = test_ahash_cycles(req, speed[i].blen,
                                                 speed[i].plen, output);
@@ -1002,13 +1003,13 @@ static inline int do_one_acipher_op(struct ablkcipher_request *req, int ret)
 }
 
 static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
-                                int blen, int sec)
+                                int blen, int secs)
 {
         unsigned long start, end;
         int bcount;
         int ret;
 
-        for (start = jiffies, end = start + sec * HZ, bcount = 0;
+        for (start = jiffies, end = start + secs * HZ, bcount = 0;
              time_before(jiffies, end); bcount++) {
                 if (enc)
                         ret = do_one_acipher_op(req,
@@ -1022,7 +1023,7 @@ static int test_acipher_jiffies(struct ablkcipher_request *req, int enc,
         }
 
         pr_cont("%d operations in %d seconds (%ld bytes)\n",
-                bcount, sec, (long)bcount * blen);
+                bcount, secs, (long)bcount * blen);
         return 0;
 }
 
@@ -1073,7 +1074,7 @@ out:
         return ret;
 }
 
-static void test_acipher_speed(const char *algo, int enc, unsigned int sec,
+static void test_acipher_speed(const char *algo, int enc, unsigned int secs,
                                struct cipher_speed_template *template,
                                unsigned int tcount, u8 *keysize)
 {
@@ -1177,9 +1178,9 @@ static void test_acipher_speed(const char *algo, int enc, unsigned int sec,
 
                         ablkcipher_request_set_crypt(req, sg, sg, *b_size, iv);
 
-                        if (sec)
+                        if (secs)
                                 ret = test_acipher_jiffies(req, enc,
-                                                           *b_size, sec);
+                                                           *b_size, secs);
                         else
                                 ret = test_acipher_cycles(req, enc,
                                                           *b_size);