Commit 0177db01 authored by Martin Schwidefsky's avatar Martin Schwidefsky
Browse files

s390/crypto: simplify return code handling 



The CPACF instructions can complete with three different condition codes:
CC=0 for successful completion, CC=1 if the protected key verification
failed, and CC=3 for partial completion.

The inline functions will restart the CPACF instruction for partial
completion, this removes the CC=3 case. The CC=1 case is only relevant
for the protected key functions of the KM, KMC, KMAC and KMCTR
instructions. As the protected key functions are not used by the
current code, there is no need for any kind of return code handling.

Reviewed-by: default avatarHarald Freudenberger <freude@linux.vnet.ibm.com>
Signed-off-by: default avatarMartin Schwidefsky <schwidefsky@de.ibm.com>
parent edc63a37

arch/s390/crypto/aes_s390.c

+6 −22
Original line number Diff line number Diff line
@@ -324,9 +324,7 @@ static int ecb_aes_crypt(struct blkcipher_desc *desc, long func, void *param, 
		u8 *out = walk->dst.virt.addr;

		u8 *in = walk->src.virt.addr;



		ret = cpacf_km(func, param, out, in, n);

		if (ret < 0 || ret != n)

			return -EIO;

		cpacf_km(func, param, out, in, n);



		nbytes &= AES_BLOCK_SIZE - 1;

		ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -460,9 +458,7 @@ static int cbc_aes_crypt(struct blkcipher_desc *desc, long func, 
		u8 *out = walk->dst.virt.addr;

		u8 *in = walk->src.virt.addr;



		ret = cpacf_kmc(func, &param, out, in, n);

		if (ret < 0 || ret != n)

			return -EIO;

		cpacf_kmc(func, &param, out, in, n);



		nbytes &= AES_BLOCK_SIZE - 1;

		ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -640,9 +636,7 @@ static int xts_aes_crypt(struct blkcipher_desc *desc, long func, 
	memcpy(pcc_param.tweak, walk->iv, sizeof(pcc_param.tweak));

	memcpy(pcc_param.key, xts_ctx->pcc_key, 32);

	/* remove decipher modifier bit from 'func' and call PCC */

	ret = cpacf_pcc(func & 0x7f, &pcc_param.key[offset]);

	if (ret < 0)

		return -EIO;

	cpacf_pcc(func & 0x7f, &pcc_param.key[offset]);



	memcpy(xts_param.key, xts_ctx->key, 32);

	memcpy(xts_param.init, pcc_param.xts, 16);
@@ -652,9 +646,7 @@ static int xts_aes_crypt(struct blkcipher_desc *desc, long func, 
		out = walk->dst.virt.addr;

		in = walk->src.virt.addr;



		ret = cpacf_km(func, &xts_param.key[offset], out, in, n);

		if (ret < 0 || ret != n)

			return -EIO;

		cpacf_km(func, &xts_param.key[offset], out, in, n);



		nbytes &= AES_BLOCK_SIZE - 1;

		ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -798,12 +790,7 @@ static int ctr_aes_crypt(struct blkcipher_desc *desc, long func, 
				n = __ctrblk_init(ctrptr, nbytes);

			else

				n = AES_BLOCK_SIZE;

			ret = cpacf_kmctr(func, sctx->key, out, in, n, ctrptr);

			if (ret < 0 || ret != n) {

				if (ctrptr == ctrblk)

					spin_unlock(&ctrblk_lock);

				return -EIO;

			}

			cpacf_kmctr(func, sctx->key, out, in, n, ctrptr);

			if (n > AES_BLOCK_SIZE)

				memcpy(ctrptr, ctrptr + n - AES_BLOCK_SIZE,

				       AES_BLOCK_SIZE);
@@ -830,10 +817,7 @@ static int ctr_aes_crypt(struct blkcipher_desc *desc, long func, 
	if (nbytes) {

		out = walk->dst.virt.addr;

		in = walk->src.virt.addr;

		ret = cpacf_kmctr(func, sctx->key, buf, in,

				  AES_BLOCK_SIZE, ctrbuf);

		if (ret < 0 || ret != AES_BLOCK_SIZE)

			return -EIO;

		cpacf_kmctr(func, sctx->key, buf, in, AES_BLOCK_SIZE, ctrbuf);

		memcpy(out, buf, nbytes);

		crypto_inc(ctrbuf, AES_BLOCK_SIZE);

		ret = blkcipher_walk_done(desc, walk, 0);

arch/s390/crypto/des_s390.c

+4 −16
Original line number Diff line number Diff line
@@ -95,9 +95,7 @@ static int ecb_desall_crypt(struct blkcipher_desc *desc, long func, 
		u8 *out = walk->dst.virt.addr;

		u8 *in = walk->src.virt.addr;



		ret = cpacf_km(func, key, out, in, n);

		if (ret < 0 || ret != n)

			return -EIO;

		cpacf_km(func, key, out, in, n);



		nbytes &= DES_BLOCK_SIZE - 1;

		ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -128,9 +126,7 @@ static int cbc_desall_crypt(struct blkcipher_desc *desc, long func, 
		u8 *out = walk->dst.virt.addr;

		u8 *in = walk->src.virt.addr;



		ret = cpacf_kmc(func, &param, out, in, n);

		if (ret < 0 || ret != n)

			return -EIO;

		cpacf_kmc(func, &param, out, in, n);



		nbytes &= DES_BLOCK_SIZE - 1;

		ret = blkcipher_walk_done(desc, walk, nbytes);
@@ -411,12 +407,7 @@ static int ctr_desall_crypt(struct blkcipher_desc *desc, long func, 
				n = __ctrblk_init(ctrptr, nbytes);

			else

				n = DES_BLOCK_SIZE;

			ret = cpacf_kmctr(func, ctx->key, out, in, n, ctrptr);

			if (ret < 0 || ret != n) {

				if (ctrptr == ctrblk)

					spin_unlock(&ctrblk_lock);

				return -EIO;

			}

			cpacf_kmctr(func, ctx->key, out, in, n, ctrptr);

			if (n > DES_BLOCK_SIZE)

				memcpy(ctrptr, ctrptr + n - DES_BLOCK_SIZE,

				       DES_BLOCK_SIZE);
@@ -441,10 +432,7 @@ static int ctr_desall_crypt(struct blkcipher_desc *desc, long func, 
	if (nbytes) {

		out = walk->dst.virt.addr;

		in = walk->src.virt.addr;

		ret = cpacf_kmctr(func, ctx->key, buf, in,

				  DES_BLOCK_SIZE, ctrbuf);

		if (ret < 0 || ret != DES_BLOCK_SIZE)

			return -EIO;

		cpacf_kmctr(func, ctx->key, buf, in, DES_BLOCK_SIZE, ctrbuf);

		memcpy(out, buf, nbytes);

		crypto_inc(ctrbuf, DES_BLOCK_SIZE);

		ret = blkcipher_walk_done(desc, walk, 0);

arch/s390/crypto/ghash_s390.c

+4 −14
Original line number Diff line number Diff line
@@ -58,7 +58,6 @@ static int ghash_update(struct shash_desc *desc, 
	struct ghash_desc_ctx *dctx = shash_desc_ctx(desc);

	unsigned int n;

	u8 *buf = dctx->buffer;

	int ret;



	if (dctx->bytes) {

		u8 *pos = buf + (GHASH_BLOCK_SIZE - dctx->bytes);
@@ -71,18 +70,14 @@ static int ghash_update(struct shash_desc *desc, 
		src += n;



		if (!dctx->bytes) {

			ret = cpacf_kimd(CPACF_KIMD_GHASH, dctx, buf,

			cpacf_kimd(CPACF_KIMD_GHASH, dctx, buf,

				   GHASH_BLOCK_SIZE);

			if (ret != GHASH_BLOCK_SIZE)

				return -EIO;

		}

	}



	n = srclen & ~(GHASH_BLOCK_SIZE - 1);

	if (n) {

		ret = cpacf_kimd(CPACF_KIMD_GHASH, dctx, src, n);

		if (ret != n)

			return -EIO;

		cpacf_kimd(CPACF_KIMD_GHASH, dctx, src, n);

		src += n;

		srclen -= n;

	}
@@ -98,17 +93,12 @@ static int ghash_update(struct shash_desc *desc, 
static int ghash_flush(struct ghash_desc_ctx *dctx)

{

	u8 *buf = dctx->buffer;

	int ret;



	if (dctx->bytes) {

		u8 *pos = buf + (GHASH_BLOCK_SIZE - dctx->bytes);



		memset(pos, 0, dctx->bytes);



		ret = cpacf_kimd(CPACF_KIMD_GHASH, dctx, buf, GHASH_BLOCK_SIZE);

		if (ret != GHASH_BLOCK_SIZE)

			return -EIO;



		cpacf_kimd(CPACF_KIMD_GHASH, dctx, buf, GHASH_BLOCK_SIZE);

		dctx->bytes = 0;

	}

arch/s390/crypto/prng.c

+23 −72
Original line number Diff line number Diff line
@@ -135,12 +135,7 @@ static int generate_entropy(u8 *ebuf, size_t nbytes) 
		else

			h = ebuf;

		/* generate sha256 from this page */

		if (cpacf_kimd(CPACF_KIMD_SHA_256, h,

			       pg, PAGE_SIZE) != PAGE_SIZE) {

			prng_errorflag = PRNG_GEN_ENTROPY_FAILED;

			ret = -EIO;

			goto out;

		}

		cpacf_kimd(CPACF_KIMD_SHA_256, h, pg, PAGE_SIZE);

		if (n < sizeof(hash))

			memcpy(ebuf, hash, n);

		ret += n;
@@ -148,7 +143,6 @@ static int generate_entropy(u8 *ebuf, size_t nbytes) 
		nbytes -= n;

	}



out:

	free_page((unsigned long)pg);

	return ret;

}
@@ -160,13 +154,11 @@ static void prng_tdes_add_entropy(void) 
{

	__u64 entropy[4];

	unsigned int i;

	int ret;



	for (i = 0; i < 16; i++) {

		ret = cpacf_kmc(CPACF_KMC_PRNG, prng_data->prngws.parm_block,

		cpacf_kmc(CPACF_KMC_PRNG, prng_data->prngws.parm_block,

			  (char *) entropy, (char *) entropy,

			  sizeof(entropy));

		BUG_ON(ret < 0 || ret != sizeof(entropy));

		memcpy(prng_data->prngws.parm_block, entropy, sizeof(entropy));

	}

}
@@ -303,21 +295,14 @@ static int __init prng_sha512_selftest(void) 
		0x21, 0xe4, 0xb0, 0x86, 0x44, 0xf6, 0x72, 0x7c,

		0x36, 0x8c, 0x5a, 0x9f, 0x7a, 0x4b, 0x3e, 0xe2 };



	int ret = 0;

	u8 buf[sizeof(random)];

	struct ppno_ws_s ws;



	memset(&ws, 0, sizeof(ws));



	/* initial seed */

	ret = cpacf_ppno(CPACF_PPNO_SHA512_DRNG_SEED, &ws, NULL, 0,

			 seed, sizeof(seed));

	if (ret < 0) {

		pr_err("The prng self test seed operation for the "

		       "SHA-512 mode failed with rc=%d\n", ret);

		prng_errorflag = PRNG_SELFTEST_FAILED;

		return -EIO;

	}

	cpacf_ppno(CPACF_PPNO_SHA512_DRNG_SEED,

		   &ws, NULL, 0, seed, sizeof(seed));



	/* check working states V and C */

	if (memcmp(ws.V, V0, sizeof(V0)) != 0
@@ -329,22 +314,10 @@ static int __init prng_sha512_selftest(void) 
	}



	/* generate random bytes */

	ret = cpacf_ppno(CPACF_PPNO_SHA512_DRNG_GEN,

	cpacf_ppno(CPACF_PPNO_SHA512_DRNG_GEN,

		   &ws, buf, sizeof(buf), NULL, 0);

	if (ret < 0) {

		pr_err("The prng self test generate operation for "

		       "the SHA-512 mode failed with rc=%d\n", ret);

		prng_errorflag = PRNG_SELFTEST_FAILED;

		return -EIO;

	}

	ret = cpacf_ppno(CPACF_PPNO_SHA512_DRNG_GEN,

	cpacf_ppno(CPACF_PPNO_SHA512_DRNG_GEN,

		   &ws, buf, sizeof(buf), NULL, 0);

	if (ret < 0) {

		pr_err("The prng self test generate operation for "

		       "the SHA-512 mode failed with rc=%d\n", ret);

		prng_errorflag = PRNG_SELFTEST_FAILED;

		return -EIO;

	}



	/* check against expected data */

	if (memcmp(buf, random, sizeof(random)) != 0) {
@@ -392,26 +365,16 @@ static int __init prng_sha512_instantiate(void) 
	get_tod_clock_ext(seed + 48);



	/* initial seed of the ppno drng */

	ret = cpacf_ppno(CPACF_PPNO_SHA512_DRNG_SEED,

	cpacf_ppno(CPACF_PPNO_SHA512_DRNG_SEED,

		   &prng_data->ppnows, NULL, 0, seed, sizeof(seed));

	if (ret < 0) {

		prng_errorflag = PRNG_SEED_FAILED;

		ret = -EIO;

		goto outfree;

	}



	/* if fips mode is enabled, generate a first block of random

	   bytes for the FIPS 140-2 Conditional Self Test */

	if (fips_enabled) {

		prng_data->prev = prng_data->buf + prng_chunk_size;

		ret = cpacf_ppno(CPACF_PPNO_SHA512_DRNG_GEN,

		cpacf_ppno(CPACF_PPNO_SHA512_DRNG_GEN,

			   &prng_data->ppnows,

			   prng_data->prev, prng_chunk_size, NULL, 0);

		if (ret < 0 || ret != prng_chunk_size) {

			prng_errorflag = PRNG_GEN_FAILED;

			ret = -EIO;

			goto outfree;

		}

	}



	return 0;
@@ -440,12 +403,8 @@ static int prng_sha512_reseed(void) 
		return ret;



	/* do a reseed of the ppno drng with this bytestring */

	ret = cpacf_ppno(CPACF_PPNO_SHA512_DRNG_SEED,

	cpacf_ppno(CPACF_PPNO_SHA512_DRNG_SEED,

		   &prng_data->ppnows, NULL, 0, seed, sizeof(seed));

	if (ret) {

		prng_errorflag = PRNG_RESEED_FAILED;

		return -EIO;

	}



	return 0;

}
@@ -463,12 +422,8 @@ static int prng_sha512_generate(u8 *buf, size_t nbytes) 
	}



	/* PPNO generate */

	ret = cpacf_ppno(CPACF_PPNO_SHA512_DRNG_GEN,

	cpacf_ppno(CPACF_PPNO_SHA512_DRNG_GEN,

		   &prng_data->ppnows, buf, nbytes, NULL, 0);

	if (ret < 0 || ret != nbytes) {

		prng_errorflag = PRNG_GEN_FAILED;

		return -EIO;

	}



	/* FIPS 140-2 Conditional Self Test */

	if (fips_enabled) {
@@ -494,7 +449,7 @@ static int prng_open(struct inode *inode, struct file *file) 
static ssize_t prng_tdes_read(struct file *file, char __user *ubuf,

			      size_t nbytes, loff_t *ppos)

{

	int chunk, n, tmp, ret = 0;

	int chunk, n, ret = 0;



	/* lock prng_data struct */

	if (mutex_lock_interruptible(&prng_data->mutex))
@@ -546,12 +501,8 @@ static ssize_t prng_tdes_read(struct file *file, char __user *ubuf, 
		 * Note: you can still get strict X9.17 conformity by setting

		 * prng_chunk_size to 8 bytes.

		 */

		tmp = cpacf_kmc(CPACF_KMC_PRNG, prng_data->prngws.parm_block,

		cpacf_kmc(CPACF_KMC_PRNG, prng_data->prngws.parm_block,

			  prng_data->buf, prng_data->buf, n);

		if (tmp < 0 || tmp != n) {

			ret = -EIO;

			break;

		}



		prng_data->prngws.byte_counter += n;

		prng_data->prngws.reseed_counter += n;

arch/s390/crypto/sha_common.c

+7 −16
Original line number Diff line number Diff line
@@ -22,8 +22,7 @@ int s390_sha_update(struct shash_desc *desc, const u8 *data, unsigned int len) 
{

	struct s390_sha_ctx *ctx = shash_desc_ctx(desc);

	unsigned int bsize = crypto_shash_blocksize(desc->tfm);

	unsigned int index;

	int ret;

	unsigned int index, n;



	/* how much is already in the buffer? */

	index = ctx->count & (bsize - 1);
@@ -35,9 +34,7 @@ int s390_sha_update(struct shash_desc *desc, const u8 *data, unsigned int len) 
	/* process one stored block */

	if (index) {

		memcpy(ctx->buf + index, data, bsize - index);

		ret = cpacf_kimd(ctx->func, ctx->state, ctx->buf, bsize);

		if (ret != bsize)

			return -EIO;

		cpacf_kimd(ctx->func, ctx->state, ctx->buf, bsize);

		data += bsize - index;

		len -= bsize - index;

		index = 0;
@@ -45,12 +42,10 @@ int s390_sha_update(struct shash_desc *desc, const u8 *data, unsigned int len) 


	/* process as many blocks as possible */

	if (len >= bsize) {

		ret = cpacf_kimd(ctx->func, ctx->state, data,

				 len & ~(bsize - 1));

		if (ret != (len & ~(bsize - 1)))

			return -EIO;

		data += ret;

		len -= ret;

		n = len & ~(bsize - 1);

		cpacf_kimd(ctx->func, ctx->state, data, n);

		data += n;

		len -= n;

	}

store:

	if (len)
@@ -66,7 +61,6 @@ int s390_sha_final(struct shash_desc *desc, u8 *out) 
	unsigned int bsize = crypto_shash_blocksize(desc->tfm);

	u64 bits;

	unsigned int index, end, plen;

	int ret;



	/* SHA-512 uses 128 bit padding length */

	plen = (bsize > SHA256_BLOCK_SIZE) ? 16 : 8;
@@ -88,10 +82,7 @@ int s390_sha_final(struct shash_desc *desc, u8 *out) 
	 */

	bits = ctx->count * 8;

	memcpy(ctx->buf + end - 8, &bits, sizeof(bits));



	ret = cpacf_kimd(ctx->func, ctx->state, ctx->buf, end);

	if (ret != end)

		return -EIO;

	cpacf_kimd(ctx->func, ctx->state, ctx->buf, end);



	/* copy digest to out */

	memcpy(out, ctx->state, crypto_shash_digestsize(desc->tfm));

CRA Git | Maintained and supported by SUSTech CRA and CCSE