Commit 64ca771c authored by Ard Biesheuvel's avatar Ard Biesheuvel Committed by Herbert Xu
Browse files

crypto: x86 - remove glue helper module 



All dependencies on the x86 glue helper module have been replaced by
local instantiations of the new ECB/CBC preprocessor helper macros, so
the glue helper module can be retired.

Acked-by: default avatarEric Biggers <ebiggers@google.com>
Signed-off-by: default avatarArd Biesheuvel <ardb@kernel.org>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 165f3573

arch/x86/crypto/Makefile

+0 −2
Original line number Diff line number Diff line
@@ -4,8 +4,6 @@ 


OBJECT_FILES_NON_STANDARD := y



obj-$(CONFIG_CRYPTO_GLUE_HELPER_X86) += glue_helper.o



obj-$(CONFIG_CRYPTO_TWOFISH_586) += twofish-i586.o

twofish-i586-y := twofish-i586-asm_32.o twofish_glue.o

obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o

arch/x86/crypto/glue_helper.c

deleted100644 → 0
+0 −155
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Shared glue code for 128bit block ciphers

 *

 * Copyright © 2012-2013 Jussi Kivilinna <jussi.kivilinna@iki.fi>

 *

 * CBC & ECB parts based on code (crypto/cbc.c,ecb.c) by:

 *   Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>

 */



#include <linux/module.h>

#include <crypto/b128ops.h>

#include <crypto/internal/skcipher.h>

#include <crypto/scatterwalk.h>

#include <asm/crypto/glue_helper.h>



int glue_ecb_req_128bit(const struct common_glue_ctx *gctx,

			struct skcipher_request *req)

{

	void *ctx = crypto_skcipher_ctx(crypto_skcipher_reqtfm(req));

	const unsigned int bsize = 128 / 8;

	struct skcipher_walk walk;

	bool fpu_enabled = false;

	unsigned int nbytes;

	int err;



	err = skcipher_walk_virt(&walk, req, false);



	while ((nbytes = walk.nbytes)) {

		const u8 *src = walk.src.virt.addr;

		u8 *dst = walk.dst.virt.addr;

		unsigned int func_bytes;

		unsigned int i;



		fpu_enabled = glue_fpu_begin(bsize, gctx->fpu_blocks_limit,

					     &walk, fpu_enabled, nbytes);

		for (i = 0; i < gctx->num_funcs; i++) {

			func_bytes = bsize * gctx->funcs[i].num_blocks;



			if (nbytes < func_bytes)

				continue;



			/* Process multi-block batch */

			do {

				gctx->funcs[i].fn_u.ecb(ctx, dst, src);

				src += func_bytes;

				dst += func_bytes;

				nbytes -= func_bytes;

			} while (nbytes >= func_bytes);



			if (nbytes < bsize)

				break;

		}

		err = skcipher_walk_done(&walk, nbytes);

	}



	glue_fpu_end(fpu_enabled);

	return err;

}

EXPORT_SYMBOL_GPL(glue_ecb_req_128bit);



int glue_cbc_encrypt_req_128bit(const common_glue_func_t fn,

				struct skcipher_request *req)

{

	void *ctx = crypto_skcipher_ctx(crypto_skcipher_reqtfm(req));

	const unsigned int bsize = 128 / 8;

	struct skcipher_walk walk;

	unsigned int nbytes;

	int err;



	err = skcipher_walk_virt(&walk, req, false);



	while ((nbytes = walk.nbytes)) {

		const u128 *src = (u128 *)walk.src.virt.addr;

		u128 *dst = (u128 *)walk.dst.virt.addr;

		u128 *iv = (u128 *)walk.iv;



		do {

			u128_xor(dst, src, iv);

			fn(ctx, (u8 *)dst, (u8 *)dst);

			iv = dst;

			src++;

			dst++;

			nbytes -= bsize;

		} while (nbytes >= bsize);



		*(u128 *)walk.iv = *iv;

		err = skcipher_walk_done(&walk, nbytes);

	}

	return err;

}

EXPORT_SYMBOL_GPL(glue_cbc_encrypt_req_128bit);



int glue_cbc_decrypt_req_128bit(const struct common_glue_ctx *gctx,

				struct skcipher_request *req)

{

	void *ctx = crypto_skcipher_ctx(crypto_skcipher_reqtfm(req));

	const unsigned int bsize = 128 / 8;

	struct skcipher_walk walk;

	bool fpu_enabled = false;

	unsigned int nbytes;

	int err;



	err = skcipher_walk_virt(&walk, req, false);



	while ((nbytes = walk.nbytes)) {

		const u128 *src = walk.src.virt.addr;

		u128 *dst = walk.dst.virt.addr;

		unsigned int func_bytes, num_blocks;

		unsigned int i;

		u128 last_iv;



		fpu_enabled = glue_fpu_begin(bsize, gctx->fpu_blocks_limit,

					     &walk, fpu_enabled, nbytes);

		/* Start of the last block. */

		src += nbytes / bsize - 1;

		dst += nbytes / bsize - 1;



		last_iv = *src;



		for (i = 0; i < gctx->num_funcs; i++) {

			num_blocks = gctx->funcs[i].num_blocks;

			func_bytes = bsize * num_blocks;



			if (nbytes < func_bytes)

				continue;



			/* Process multi-block batch */

			do {

				src -= num_blocks - 1;

				dst -= num_blocks - 1;



				gctx->funcs[i].fn_u.cbc(ctx, (u8 *)dst,

							(const u8 *)src);



				nbytes -= func_bytes;

				if (nbytes < bsize)

					goto done;



				u128_xor(dst, dst, --src);

				dst--;

			} while (nbytes >= func_bytes);

		}

done:

		u128_xor(dst, dst, (u128 *)walk.iv);

		*(u128 *)walk.iv = last_iv;

		err = skcipher_walk_done(&walk, nbytes);

	}



	glue_fpu_end(fpu_enabled);

	return err;

}

EXPORT_SYMBOL_GPL(glue_cbc_decrypt_req_128bit);



MODULE_LICENSE("GPL");

arch/x86/include/asm/crypto/glue_helper.h

deleted100644 → 0
+0 −74
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Shared glue code for 128bit block ciphers

 */



#ifndef _CRYPTO_GLUE_HELPER_H

#define _CRYPTO_GLUE_HELPER_H



#include <crypto/internal/skcipher.h>

#include <linux/kernel.h>

#include <asm/fpu/api.h>



typedef void (*common_glue_func_t)(const void *ctx, u8 *dst, const u8 *src);

typedef void (*common_glue_cbc_func_t)(const void *ctx, u8 *dst, const u8 *src);



struct common_glue_func_entry {

	unsigned int num_blocks; /* number of blocks that @fn will process */

	union {

		common_glue_func_t ecb;

		common_glue_cbc_func_t cbc;

	} fn_u;

};



struct common_glue_ctx {

	unsigned int num_funcs;

	int fpu_blocks_limit; /* -1 means fpu not needed at all */



	/*

	 * First funcs entry must have largest num_blocks and last funcs entry

	 * must have num_blocks == 1!

	 */

	struct common_glue_func_entry funcs[];

};



static inline bool glue_fpu_begin(unsigned int bsize, int fpu_blocks_limit,

				  struct skcipher_walk *walk,

				  bool fpu_enabled, unsigned int nbytes)

{

	if (likely(fpu_blocks_limit < 0))

		return false;



	if (fpu_enabled)

		return true;



	/*

	 * Vector-registers are only used when chunk to be processed is large

	 * enough, so do not enable FPU until it is necessary.

	 */

	if (nbytes < bsize * (unsigned int)fpu_blocks_limit)

		return false;



	/* prevent sleeping if FPU is in use */

	skcipher_walk_atomise(walk);



	kernel_fpu_begin();

	return true;

}



static inline void glue_fpu_end(bool fpu_enabled)

{

	if (fpu_enabled)

		kernel_fpu_end();

}



extern int glue_ecb_req_128bit(const struct common_glue_ctx *gctx,

			       struct skcipher_request *req);



extern int glue_cbc_encrypt_req_128bit(const common_glue_func_t fn,

				       struct skcipher_request *req);



extern int glue_cbc_decrypt_req_128bit(const struct common_glue_ctx *gctx,

				       struct skcipher_request *req);



#endif /* _CRYPTO_GLUE_HELPER_H */

crypto/Kconfig

+0 −5
Original line number Diff line number Diff line
@@ -210,11 +210,6 @@ config CRYPTO_SIMD 
	tristate

	select CRYPTO_CRYPTD



config CRYPTO_GLUE_HELPER_X86

	tristate

	depends on X86

	select CRYPTO_SKCIPHER



config CRYPTO_ENGINE

	tristate

crypto/skcipher.c

+0 −6
Original line number Diff line number Diff line
@@ -491,12 +491,6 @@ int skcipher_walk_virt(struct skcipher_walk *walk, 
}

EXPORT_SYMBOL_GPL(skcipher_walk_virt);



void skcipher_walk_atomise(struct skcipher_walk *walk)

{

	walk->flags &= ~SKCIPHER_WALK_SLEEP;

}

EXPORT_SYMBOL_GPL(skcipher_walk_atomise);



int skcipher_walk_async(struct skcipher_walk *walk,

			struct skcipher_request *req)

{