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: Eric Biggers <ebiggers@google.com>
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/arch/x86/crypto/Makefile b/arch/x86/crypto/Makefile
index a31de0c..b28e36b 100644 (file)
--- a/arch/x86/crypto/Makefile
+++ b/arch/x86/crypto/Makefile
@@ -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

diff --git a/arch/x86/crypto/glue_helper.c b/arch/x86/crypto/glue_helper.c
deleted file mode 100644 (file)
index 895d341..0000000
--- a/arch/x86/crypto/glue_helper.c
+++ /dev/null
@@ -1,155 +0,0 @@
-// 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");

diff --git a/arch/x86/include/asm/crypto/glue_helper.h b/arch/x86/include/asm/crypto/glue_helper.h
deleted file mode 100644 (file)
index 23e09ef..0000000
--- a/arch/x86/include/asm/crypto/glue_helper.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/* 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 */

diff --git a/crypto/Kconfig b/crypto/Kconfig
index b218265..94f0fde 100644 (file)
--- a/crypto/Kconfig
+++ b/crypto/Kconfig
@@ -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
 

diff --git a/crypto/skcipher.c b/crypto/skcipher.c
index ff16d05..a153762 100644 (file)
--- a/crypto/skcipher.c
+++ b/crypto/skcipher.c
@@ -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)
 {

diff --git a/include/crypto/internal/skcipher.h b/include/crypto/internal/skcipher.h
index 9dd6c0c..a2339f8 100644 (file)
--- a/include/crypto/internal/skcipher.h
+++ b/include/crypto/internal/skcipher.h
@@ -133,7 +133,6 @@ int skcipher_walk_done(struct skcipher_walk *walk, int err);
 int skcipher_walk_virt(struct skcipher_walk *walk,
                       struct skcipher_request *req,
                       bool atomic);
-void skcipher_walk_atomise(struct skcipher_walk *walk);
 int skcipher_walk_async(struct skcipher_walk *walk,
                        struct skcipher_request *req);
 int skcipher_walk_aead_encrypt(struct skcipher_walk *walk,