Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 53709dde authored by Jussi Kivilinna's avatar Jussi Kivilinna Committed by Herbert Xu
Browse files

crypto: twofish-x86_64-3way - use crypto_[un]register_algs 



Combine all crypto_alg to be registered and use new crypto_[un]register_algs
functions. Simplifies init/exit code and reduce object size.

Signed-off-by: default avatarJussi Kivilinna <jussi.kivilinna@mbnet.fi>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 35474c3b

arch/x86/crypto/twofish_glue_3way.c

+89 −130
Original line number Diff line number Diff line
@@ -123,28 +123,6 @@ static int ecb_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 
	return ecb_crypt(desc, &walk, twofish_dec_blk, twofish_dec_blk_3way);

}



static struct crypto_alg blk_ecb_alg = {

	.cra_name		= "ecb(twofish)",

	.cra_driver_name	= "ecb-twofish-3way",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= TF_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct twofish_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_list		= LIST_HEAD_INIT(blk_ecb_alg.cra_list),

	.cra_u = {

		.blkcipher = {

			.min_keysize	= TF_MIN_KEY_SIZE,

			.max_keysize	= TF_MAX_KEY_SIZE,

			.setkey		= twofish_setkey,

			.encrypt	= ecb_encrypt,

			.decrypt	= ecb_decrypt,

		},

	},

};



static unsigned int __cbc_encrypt(struct blkcipher_desc *desc,

				  struct blkcipher_walk *walk)

{
@@ -268,29 +246,6 @@ static int cbc_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 
	return err;

}



static struct crypto_alg blk_cbc_alg = {

	.cra_name		= "cbc(twofish)",

	.cra_driver_name	= "cbc-twofish-3way",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= TF_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct twofish_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_list		= LIST_HEAD_INIT(blk_cbc_alg.cra_list),

	.cra_u = {

		.blkcipher = {

			.min_keysize	= TF_MIN_KEY_SIZE,

			.max_keysize	= TF_MAX_KEY_SIZE,

			.ivsize		= TF_BLOCK_SIZE,

			.setkey		= twofish_setkey,

			.encrypt	= cbc_encrypt,

			.decrypt	= cbc_decrypt,

		},

	},

};



static inline void u128_to_be128(be128 *dst, const u128 *src)

{

	dst->a = cpu_to_be64(src->a);
@@ -412,29 +367,6 @@ static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst, 
	return err;

}



static struct crypto_alg blk_ctr_alg = {

	.cra_name		= "ctr(twofish)",

	.cra_driver_name	= "ctr-twofish-3way",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= 1,

	.cra_ctxsize		= sizeof(struct twofish_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_list		= LIST_HEAD_INIT(blk_ctr_alg.cra_list),

	.cra_u = {

		.blkcipher = {

			.min_keysize	= TF_MIN_KEY_SIZE,

			.max_keysize	= TF_MAX_KEY_SIZE,

			.ivsize		= TF_BLOCK_SIZE,

			.setkey		= twofish_setkey,

			.encrypt	= ctr_crypt,

			.decrypt	= ctr_crypt,

		},

	},

};



static void encrypt_callback(void *priv, u8 *srcdst, unsigned int nbytes)

{

	const unsigned int bsize = TF_BLOCK_SIZE;
@@ -525,30 +457,6 @@ static void lrw_exit_tfm(struct crypto_tfm *tfm) 
	lrw_free_table(&ctx->lrw_table);

}



static struct crypto_alg blk_lrw_alg = {

	.cra_name		= "lrw(twofish)",

	.cra_driver_name	= "lrw-twofish-3way",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= TF_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct twofish_lrw_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_list		= LIST_HEAD_INIT(blk_lrw_alg.cra_list),

	.cra_exit		= lrw_exit_tfm,

	.cra_u = {

		.blkcipher = {

			.min_keysize	= TF_MIN_KEY_SIZE + TF_BLOCK_SIZE,

			.max_keysize	= TF_MAX_KEY_SIZE + TF_BLOCK_SIZE,

			.ivsize		= TF_BLOCK_SIZE,

			.setkey		= lrw_twofish_setkey,

			.encrypt	= lrw_encrypt,

			.decrypt	= lrw_decrypt,

		},

	},

};



struct twofish_xts_ctx {

	struct twofish_ctx tweak_ctx;

	struct twofish_ctx crypt_ctx;
@@ -615,7 +523,91 @@ static int xts_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, 
	return xts_crypt(desc, dst, src, nbytes, &req);

}



static struct crypto_alg blk_xts_alg = {

static struct crypto_alg tf_algs[5] = { {

	.cra_name		= "ecb(twofish)",

	.cra_driver_name	= "ecb-twofish-3way",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= TF_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct twofish_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_list		= LIST_HEAD_INIT(tf_algs[0].cra_list),

	.cra_u = {

		.blkcipher = {

			.min_keysize	= TF_MIN_KEY_SIZE,

			.max_keysize	= TF_MAX_KEY_SIZE,

			.setkey		= twofish_setkey,

			.encrypt	= ecb_encrypt,

			.decrypt	= ecb_decrypt,

		},

	},

}, {

	.cra_name		= "cbc(twofish)",

	.cra_driver_name	= "cbc-twofish-3way",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= TF_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct twofish_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_list		= LIST_HEAD_INIT(tf_algs[1].cra_list),

	.cra_u = {

		.blkcipher = {

			.min_keysize	= TF_MIN_KEY_SIZE,

			.max_keysize	= TF_MAX_KEY_SIZE,

			.ivsize		= TF_BLOCK_SIZE,

			.setkey		= twofish_setkey,

			.encrypt	= cbc_encrypt,

			.decrypt	= cbc_decrypt,

		},

	},

}, {

	.cra_name		= "ctr(twofish)",

	.cra_driver_name	= "ctr-twofish-3way",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= 1,

	.cra_ctxsize		= sizeof(struct twofish_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_list		= LIST_HEAD_INIT(tf_algs[2].cra_list),

	.cra_u = {

		.blkcipher = {

			.min_keysize	= TF_MIN_KEY_SIZE,

			.max_keysize	= TF_MAX_KEY_SIZE,

			.ivsize		= TF_BLOCK_SIZE,

			.setkey		= twofish_setkey,

			.encrypt	= ctr_crypt,

			.decrypt	= ctr_crypt,

		},

	},

}, {

	.cra_name		= "lrw(twofish)",

	.cra_driver_name	= "lrw-twofish-3way",

	.cra_priority		= 300,

	.cra_flags		= CRYPTO_ALG_TYPE_BLKCIPHER,

	.cra_blocksize		= TF_BLOCK_SIZE,

	.cra_ctxsize		= sizeof(struct twofish_lrw_ctx),

	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_list		= LIST_HEAD_INIT(tf_algs[3].cra_list),

	.cra_exit		= lrw_exit_tfm,

	.cra_u = {

		.blkcipher = {

			.min_keysize	= TF_MIN_KEY_SIZE + TF_BLOCK_SIZE,

			.max_keysize	= TF_MAX_KEY_SIZE + TF_BLOCK_SIZE,

			.ivsize		= TF_BLOCK_SIZE,

			.setkey		= lrw_twofish_setkey,

			.encrypt	= lrw_encrypt,

			.decrypt	= lrw_decrypt,

		},

	},

}, {

	.cra_name		= "xts(twofish)",

	.cra_driver_name	= "xts-twofish-3way",

	.cra_priority		= 300,
@@ -625,7 +617,7 @@ static struct crypto_alg blk_xts_alg = { 
	.cra_alignmask		= 0,

	.cra_type		= &crypto_blkcipher_type,

	.cra_module		= THIS_MODULE,

	.cra_list		= LIST_HEAD_INIT(blk_xts_alg.cra_list),

	.cra_list		= LIST_HEAD_INIT(tf_algs[4].cra_list),

	.cra_u = {

		.blkcipher = {

			.min_keysize	= TF_MIN_KEY_SIZE * 2,
@@ -636,7 +628,7 @@ static struct crypto_alg blk_xts_alg = { 
			.decrypt	= xts_decrypt,

		},

	},

};

} };



static bool is_blacklisted_cpu(void)

{
@@ -678,8 +670,6 @@ MODULE_PARM_DESC(force, "Force module load, ignore CPU blacklist"); 


int __init init(void)

{

	int err;



	if (!force && is_blacklisted_cpu()) {

		printk(KERN_INFO

			"twofish-x86_64-3way: performance on this CPU "
@@ -688,43 +678,12 @@ int __init init(void) 
		return -ENODEV;

	}



	err = crypto_register_alg(&blk_ecb_alg);

	if (err)

		goto ecb_err;

	err = crypto_register_alg(&blk_cbc_alg);

	if (err)

		goto cbc_err;

	err = crypto_register_alg(&blk_ctr_alg);

	if (err)

		goto ctr_err;

	err = crypto_register_alg(&blk_lrw_alg);

	if (err)

		goto blk_lrw_err;

	err = crypto_register_alg(&blk_xts_alg);

	if (err)

		goto blk_xts_err;



	return 0;



blk_xts_err:

	crypto_unregister_alg(&blk_lrw_alg);

blk_lrw_err:

	crypto_unregister_alg(&blk_ctr_alg);

ctr_err:

	crypto_unregister_alg(&blk_cbc_alg);

cbc_err:

	crypto_unregister_alg(&blk_ecb_alg);

ecb_err:

	return err;

	return crypto_register_algs(tf_algs, ARRAY_SIZE(tf_algs));

}



void __exit fini(void)

{

	crypto_unregister_alg(&blk_xts_alg);

	crypto_unregister_alg(&blk_lrw_alg);

	crypto_unregister_alg(&blk_ctr_alg);

	crypto_unregister_alg(&blk_cbc_alg);

	crypto_unregister_alg(&blk_ecb_alg);

	crypto_unregister_algs(tf_algs, ARRAY_SIZE(tf_algs));

}



module_init(init);