Commit 3e3dc25f authored by Mark Rustad's avatar Mark Rustad Committed by Herbert Xu
Browse files

crypto: Resolve shadow warnings 



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

Signed-off-by: default avatarMark Rustad <mark.d.rustad@intel.com>
Signed-off-by: default avatarJeff Kirsher <jeffrey.t.kirsher@intel.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 4839ddca

crypto/cryptd.c

+6 −6
Original line number Diff line number Diff line
@@ -233,7 +233,7 @@ static void cryptd_blkcipher_decrypt(struct crypto_async_request *req, int err) 
}



static int cryptd_blkcipher_enqueue(struct ablkcipher_request *req,

				    crypto_completion_t complete)

				    crypto_completion_t compl)

{

	struct cryptd_blkcipher_request_ctx *rctx = ablkcipher_request_ctx(req);

	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
@@ -241,7 +241,7 @@ static int cryptd_blkcipher_enqueue(struct ablkcipher_request *req, 


	queue = cryptd_get_queue(crypto_ablkcipher_tfm(tfm));

	rctx->complete = req->base.complete;

	req->base.complete = complete;

	req->base.complete = compl;



	return cryptd_enqueue_request(queue, &req->base);

}
@@ -414,7 +414,7 @@ static int cryptd_hash_setkey(struct crypto_ahash *parent, 
}



static int cryptd_hash_enqueue(struct ahash_request *req,

				crypto_completion_t complete)

				crypto_completion_t compl)

{

	struct cryptd_hash_request_ctx *rctx = ahash_request_ctx(req);

	struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
@@ -422,7 +422,7 @@ static int cryptd_hash_enqueue(struct ahash_request *req, 
		cryptd_get_queue(crypto_ahash_tfm(tfm));



	rctx->complete = req->base.complete;

	req->base.complete = complete;

	req->base.complete = compl;



	return cryptd_enqueue_request(queue, &req->base);

}
@@ -667,14 +667,14 @@ static void cryptd_aead_decrypt(struct crypto_async_request *areq, int err) 
}



static int cryptd_aead_enqueue(struct aead_request *req,

				    crypto_completion_t complete)

				    crypto_completion_t compl)

{

	struct cryptd_aead_request_ctx *rctx = aead_request_ctx(req);

	struct crypto_aead *tfm = crypto_aead_reqtfm(req);

	struct cryptd_queue *queue = cryptd_get_queue(crypto_aead_tfm(tfm));



	rctx->complete = req->base.complete;

	req->base.complete = complete;

	req->base.complete = compl;

	return cryptd_enqueue_request(queue, &req->base);

}

crypto/eseqiv.c

+4 −4
Original line number Diff line number Diff line
@@ -68,7 +68,7 @@ static int eseqiv_givencrypt(struct skcipher_givcrypt_request *req) 
	struct eseqiv_ctx *ctx = crypto_ablkcipher_ctx(geniv);

	struct eseqiv_request_ctx *reqctx = skcipher_givcrypt_reqctx(req);

	struct ablkcipher_request *subreq;

	crypto_completion_t complete;

	crypto_completion_t compl;

	void *data;

	struct scatterlist *osrc, *odst;

	struct scatterlist *dst;
@@ -86,7 +86,7 @@ static int eseqiv_givencrypt(struct skcipher_givcrypt_request *req) 
	ablkcipher_request_set_tfm(subreq, skcipher_geniv_cipher(geniv));



	giv = req->giv;

	complete = req->creq.base.complete;

	compl = req->creq.base.complete;

	data = req->creq.base.data;



	osrc = req->creq.src;
@@ -101,11 +101,11 @@ static int eseqiv_givencrypt(struct skcipher_givcrypt_request *req) 
	if (vsrc != giv + ivsize && vdst != giv + ivsize) {

		giv = PTR_ALIGN((u8 *)reqctx->tail,

				crypto_ablkcipher_alignmask(geniv) + 1);

		complete = eseqiv_complete;

		compl = eseqiv_complete;

		data = req;

	}



	ablkcipher_request_set_callback(subreq, req->creq.base.flags, complete,

	ablkcipher_request_set_callback(subreq, req->creq.base.flags, compl,

					data);



	sg_init_table(reqctx->src, 2);

crypto/gcm.c

+15 −15
Original line number Diff line number Diff line
@@ -228,14 +228,14 @@ static void gcm_hash_final_done(struct crypto_async_request *areq, int err); 


static int gcm_hash_update(struct aead_request *req,

			   struct crypto_gcm_req_priv_ctx *pctx,

			   crypto_completion_t complete,

			   crypto_completion_t compl,

			   struct scatterlist *src,

			   unsigned int len)

{

	struct ahash_request *ahreq = &pctx->u.ahreq;



	ahash_request_set_callback(ahreq, aead_request_flags(req),

				   complete, req);

				   compl, req);

	ahash_request_set_crypt(ahreq, src, NULL, len);



	return crypto_ahash_update(ahreq);
@@ -244,12 +244,12 @@ static int gcm_hash_update(struct aead_request *req, 
static int gcm_hash_remain(struct aead_request *req,

			   struct crypto_gcm_req_priv_ctx *pctx,

			   unsigned int remain,

			   crypto_completion_t complete)

			   crypto_completion_t compl)

{

	struct ahash_request *ahreq = &pctx->u.ahreq;



	ahash_request_set_callback(ahreq, aead_request_flags(req),

				   complete, req);

				   compl, req);

	sg_init_one(pctx->src, gcm_zeroes, remain);

	ahash_request_set_crypt(ahreq, pctx->src, NULL, remain);
@@ -375,14 +375,14 @@ static void __gcm_hash_assoc_remain_done(struct aead_request *req, int err) 
{

	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);

	struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;

	crypto_completion_t complete;

	crypto_completion_t compl;

	unsigned int remain = 0;



	if (!err && gctx->cryptlen) {

		remain = gcm_remain(gctx->cryptlen);

		complete = remain ? gcm_hash_crypt_done :

		compl = remain ? gcm_hash_crypt_done :

			gcm_hash_crypt_remain_done;

		err = gcm_hash_update(req, pctx, complete,

		err = gcm_hash_update(req, pctx, compl,

				      gctx->src, gctx->cryptlen);

		if (err == -EINPROGRESS || err == -EBUSY)

			return;
@@ -429,14 +429,14 @@ static void gcm_hash_assoc_done(struct crypto_async_request *areq, int err) 
static void __gcm_hash_init_done(struct aead_request *req, int err)

{

	struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);

	crypto_completion_t complete;

	crypto_completion_t compl;

	unsigned int remain = 0;



	if (!err && req->assoclen) {

		remain = gcm_remain(req->assoclen);

		complete = remain ? gcm_hash_assoc_done :

		compl = remain ? gcm_hash_assoc_done :

			gcm_hash_assoc_remain_done;

		err = gcm_hash_update(req, pctx, complete,

		err = gcm_hash_update(req, pctx, compl,

				      req->assoc, req->assoclen);

		if (err == -EINPROGRESS || err == -EBUSY)

			return;
@@ -462,7 +462,7 @@ static int gcm_hash(struct aead_request *req, 
	struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;

	struct crypto_gcm_ctx *ctx = crypto_tfm_ctx(req->base.tfm);

	unsigned int remain;

	crypto_completion_t complete;

	crypto_completion_t compl;

	int err;



	ahash_request_set_tfm(ahreq, ctx->ghash);
@@ -473,8 +473,8 @@ static int gcm_hash(struct aead_request *req, 
	if (err)

		return err;

	remain = gcm_remain(req->assoclen);

	complete = remain ? gcm_hash_assoc_done : gcm_hash_assoc_remain_done;

	err = gcm_hash_update(req, pctx, complete, req->assoc, req->assoclen);

	compl = remain ? gcm_hash_assoc_done : gcm_hash_assoc_remain_done;

	err = gcm_hash_update(req, pctx, compl, req->assoc, req->assoclen);

	if (err)

		return err;

	if (remain) {
@@ -484,8 +484,8 @@ static int gcm_hash(struct aead_request *req, 
			return err;

	}

	remain = gcm_remain(gctx->cryptlen);

	complete = remain ? gcm_hash_crypt_done : gcm_hash_crypt_remain_done;

	err = gcm_hash_update(req, pctx, complete, gctx->src, gctx->cryptlen);

	compl = remain ? gcm_hash_crypt_done : gcm_hash_crypt_remain_done;

	err = gcm_hash_update(req, pctx, compl, gctx->src, gctx->cryptlen);

	if (err)

		return err;

	if (remain) {

crypto/seqiv.c

+8 −8
Original line number Diff line number Diff line
@@ -100,7 +100,7 @@ static int seqiv_givencrypt(struct skcipher_givcrypt_request *req) 
	struct crypto_ablkcipher *geniv = skcipher_givcrypt_reqtfm(req);

	struct seqiv_ctx *ctx = crypto_ablkcipher_ctx(geniv);

	struct ablkcipher_request *subreq = skcipher_givcrypt_reqctx(req);

	crypto_completion_t complete;

	crypto_completion_t compl;

	void *data;

	u8 *info;

	unsigned int ivsize;
@@ -108,7 +108,7 @@ static int seqiv_givencrypt(struct skcipher_givcrypt_request *req) 


	ablkcipher_request_set_tfm(subreq, skcipher_geniv_cipher(geniv));



	complete = req->creq.base.complete;

	compl = req->creq.base.complete;

	data = req->creq.base.data;

	info = req->creq.info;
@@ -122,11 +122,11 @@ static int seqiv_givencrypt(struct skcipher_givcrypt_request *req) 
		if (!info)

			return -ENOMEM;



		complete = seqiv_complete;

		compl = seqiv_complete;

		data = req;

	}



	ablkcipher_request_set_callback(subreq, req->creq.base.flags, complete,

	ablkcipher_request_set_callback(subreq, req->creq.base.flags, compl,

					data);

	ablkcipher_request_set_crypt(subreq, req->creq.src, req->creq.dst,

				     req->creq.nbytes, info);
@@ -146,7 +146,7 @@ static int seqiv_aead_givencrypt(struct aead_givcrypt_request *req) 
	struct seqiv_ctx *ctx = crypto_aead_ctx(geniv);

	struct aead_request *areq = &req->areq;

	struct aead_request *subreq = aead_givcrypt_reqctx(req);

	crypto_completion_t complete;

	crypto_completion_t compl;

	void *data;

	u8 *info;

	unsigned int ivsize;
@@ -154,7 +154,7 @@ static int seqiv_aead_givencrypt(struct aead_givcrypt_request *req) 


	aead_request_set_tfm(subreq, aead_geniv_base(geniv));



	complete = areq->base.complete;

	compl = areq->base.complete;

	data = areq->base.data;

	info = areq->iv;
@@ -168,11 +168,11 @@ static int seqiv_aead_givencrypt(struct aead_givcrypt_request *req) 
		if (!info)

			return -ENOMEM;



		complete = seqiv_aead_complete;

		compl = seqiv_aead_complete;

		data = req;

	}



	aead_request_set_callback(subreq, areq->base.flags, complete, data);

	aead_request_set_callback(subreq, areq->base.flags, compl, data);

	aead_request_set_crypt(subreq, areq->src, areq->dst, areq->cryptlen,

			       info);

	aead_request_set_assoc(subreq, areq->assoc, areq->assoclen);

crypto/tcrypt.c

+39 −38
Original line number Diff line number Diff line
@@ -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);

CRA Git | Maintained and supported by SUSTech CRA and CCSE