crypto: mips/sha256 - implement library instead of shash

Instead of providing crypto_shash algorithms for the arch-optimized
SHA-256 code, instead implement the SHA-256 library.  This is much
simpler, it makes the SHA-256 library functions be arch-optimized, and
it fixes the longstanding issue where the arch-optimized SHA-256 was
disabled by default.  SHA-256 still remains available through
crypto_shash, but individual architectures no longer need to handle it.

Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/arch/mips/cavium-octeon/Kconfig b/arch/mips/cavium-octeon/Kconfig
index 450e979ef5d93723b4c2dca7225d1d4ad74983d8..11f4aa6e80e9b50267f8cd768b456fa0f1ad4ef2 100644 (file)
--- a/arch/mips/cavium-octeon/Kconfig
+++ b/arch/mips/cavium-octeon/Kconfig
@@ -23,6 +23,12 @@ config CAVIUM_OCTEON_CVMSEG_SIZE
          legally range is from zero to 54 cache blocks (i.e. CVMSEG LM is
          between zero and 6192 bytes).
 
+config CRYPTO_SHA256_OCTEON
+       tristate
+       default CRYPTO_LIB_SHA256
+       select CRYPTO_ARCH_HAVE_LIB_SHA256
+       select CRYPTO_LIB_SHA256_GENERIC
+
 endif # CPU_CAVIUM_OCTEON
 
 if CAVIUM_OCTEON_SOC

diff --git a/arch/mips/cavium-octeon/crypto/octeon-sha256.c b/arch/mips/cavium-octeon/crypto/octeon-sha256.c
index 8e85ea65387c8b1de1d1a193b27b83ab25790232..f169054852bcb2af66b9a7a9ca01d68c1f786951 100644 (file)
--- a/arch/mips/cavium-octeon/crypto/octeon-sha256.c
+++ b/arch/mips/cavium-octeon/crypto/octeon-sha256.c
@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
- * Cryptographic API.
- *
- * SHA-224 and SHA-256 Secure Hash Algorithm.
+ * SHA-256 Secure Hash Algorithm.
  *
  * Adapted for OCTEON by Aaro Koskinen <aaro.koskinen@iki.fi>.
  *
@@ -15,9 +13,7 @@
  */
 
 #include <asm/octeon/octeon.h>
-#include <crypto/internal/hash.h>
-#include <crypto/sha2.h>
-#include <crypto/sha256_base.h>
+#include <crypto/internal/sha2.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 
@@ -27,31 +23,24 @@
  * We pass everything as 64-bit. OCTEON can handle misaligned data.
  */
 
-static void octeon_sha256_store_hash(struct crypto_sha256_state *sctx)
+void sha256_blocks_arch(u32 state[SHA256_STATE_WORDS],
+                       const u8 *data, size_t nblocks)
 {
-       u64 *hash = (u64 *)sctx->state;
-
-       write_octeon_64bit_hash_dword(hash[0], 0);
-       write_octeon_64bit_hash_dword(hash[1], 1);
-       write_octeon_64bit_hash_dword(hash[2], 2);
-       write_octeon_64bit_hash_dword(hash[3], 3);
-}
+       struct octeon_cop2_state cop2_state;
+       u64 *state64 = (u64 *)state;
+       unsigned long flags;
 
-static void octeon_sha256_read_hash(struct crypto_sha256_state *sctx)
-{
-       u64 *hash = (u64 *)sctx->state;
+       if (!octeon_has_crypto())
+               return sha256_blocks_generic(state, data, nblocks);
 
-       hash[0] = read_octeon_64bit_hash_dword(0);
-       hash[1] = read_octeon_64bit_hash_dword(1);
-       hash[2] = read_octeon_64bit_hash_dword(2);
-       hash[3] = read_octeon_64bit_hash_dword(3);
-}
+       flags = octeon_crypto_enable(&cop2_state);
+       write_octeon_64bit_hash_dword(state64[0], 0);
+       write_octeon_64bit_hash_dword(state64[1], 1);
+       write_octeon_64bit_hash_dword(state64[2], 2);
+       write_octeon_64bit_hash_dword(state64[3], 3);
 
-static void octeon_sha256_transform(struct crypto_sha256_state *sctx,
-                                   const u8 *src, int blocks)
-{
        do {
-               const u64 *block = (const u64 *)src;
+               const u64 *block = (const u64 *)data;
 
                write_octeon_64bit_block_dword(block[0], 0);
                write_octeon_64bit_block_dword(block[1], 1);
@@ -62,93 +51,23 @@ static void octeon_sha256_transform(struct crypto_sha256_state *sctx,
                write_octeon_64bit_block_dword(block[6], 6);
                octeon_sha256_start(block[7]);
 
-               src += SHA256_BLOCK_SIZE;
-       } while (--blocks);
-}
-
-static int octeon_sha256_update(struct shash_desc *desc, const u8 *data,
-                               unsigned int len)
-{
-       struct crypto_sha256_state *sctx = shash_desc_ctx(desc);
-       struct octeon_cop2_state state;
-       unsigned long flags;
-       int remain;
-
-       flags = octeon_crypto_enable(&state);
-       octeon_sha256_store_hash(sctx);
-
-       remain = sha256_base_do_update_blocks(desc, data, len,
-                                             octeon_sha256_transform);
+               data += SHA256_BLOCK_SIZE;
+       } while (--nblocks);
 
-       octeon_sha256_read_hash(sctx);
-       octeon_crypto_disable(&state, flags);
-       return remain;
+       state64[0] = read_octeon_64bit_hash_dword(0);
+       state64[1] = read_octeon_64bit_hash_dword(1);
+       state64[2] = read_octeon_64bit_hash_dword(2);
+       state64[3] = read_octeon_64bit_hash_dword(3);
+       octeon_crypto_disable(&cop2_state, flags);
 }
+EXPORT_SYMBOL(sha256_blocks_arch);
 
-static int octeon_sha256_finup(struct shash_desc *desc, const u8 *src,
-                              unsigned int len, u8 *out)
+bool sha256_is_arch_optimized(void)
 {
-       struct crypto_sha256_state *sctx = shash_desc_ctx(desc);
-       struct octeon_cop2_state state;
-       unsigned long flags;
-
-       flags = octeon_crypto_enable(&state);
-       octeon_sha256_store_hash(sctx);
-
-       sha256_base_do_finup(desc, src, len, octeon_sha256_transform);
-
-       octeon_sha256_read_hash(sctx);
-       octeon_crypto_disable(&state, flags);
-       return sha256_base_finish(desc, out);
+       return octeon_has_crypto();
 }
-
-static struct shash_alg octeon_sha256_algs[2] = { {
-       .digestsize     =       SHA256_DIGEST_SIZE,
-       .init           =       sha256_base_init,
-       .update         =       octeon_sha256_update,
-       .finup          =       octeon_sha256_finup,
-       .descsize       =       sizeof(struct crypto_sha256_state),
-       .base           =       {
-               .cra_name       =       "sha256",
-               .cra_driver_name=       "octeon-sha256",
-               .cra_priority   =       OCTEON_CR_OPCODE_PRIORITY,
-               .cra_flags      =       CRYPTO_AHASH_ALG_BLOCK_ONLY,
-               .cra_blocksize  =       SHA256_BLOCK_SIZE,
-               .cra_module     =       THIS_MODULE,
-       }
-}, {
-       .digestsize     =       SHA224_DIGEST_SIZE,
-       .init           =       sha224_base_init,
-       .update         =       octeon_sha256_update,
-       .finup          =       octeon_sha256_finup,
-       .descsize       =       sizeof(struct crypto_sha256_state),
-       .base           =       {
-               .cra_name       =       "sha224",
-               .cra_driver_name=       "octeon-sha224",
-               .cra_priority   =       OCTEON_CR_OPCODE_PRIORITY,
-               .cra_flags      =       CRYPTO_AHASH_ALG_BLOCK_ONLY,
-               .cra_blocksize  =       SHA224_BLOCK_SIZE,
-               .cra_module     =       THIS_MODULE,
-       }
-} };
-
-static int __init octeon_sha256_mod_init(void)
-{
-       if (!octeon_has_crypto())
-               return -ENOTSUPP;
-       return crypto_register_shashes(octeon_sha256_algs,
-                                      ARRAY_SIZE(octeon_sha256_algs));
-}
-
-static void __exit octeon_sha256_mod_fini(void)
-{
-       crypto_unregister_shashes(octeon_sha256_algs,
-                                 ARRAY_SIZE(octeon_sha256_algs));
-}
-
-module_init(octeon_sha256_mod_init);
-module_exit(octeon_sha256_mod_fini);
+EXPORT_SYMBOL(sha256_is_arch_optimized);
 
 MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("SHA-224 and SHA-256 Secure Hash Algorithm (OCTEON)");
+MODULE_DESCRIPTION("SHA-256 Secure Hash Algorithm (OCTEON)");
 MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");

diff --git a/arch/mips/configs/cavium_octeon_defconfig b/arch/mips/configs/cavium_octeon_defconfig
index f523ee6f25bfef85337046d64facd308e2b237a7..88ae0aa85364b10970da00c7bdb0d91d87d77cb6 100644 (file)
--- a/arch/mips/configs/cavium_octeon_defconfig
+++ b/arch/mips/configs/cavium_octeon_defconfig
@@ -157,7 +157,6 @@ CONFIG_CRYPTO_CBC=y
 CONFIG_CRYPTO_HMAC=y
 CONFIG_CRYPTO_MD5_OCTEON=y
 CONFIG_CRYPTO_SHA1_OCTEON=m
-CONFIG_CRYPTO_SHA256_OCTEON=m
 CONFIG_CRYPTO_SHA512_OCTEON=m
 CONFIG_CRYPTO_DES=y
 CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y

diff --git a/arch/mips/crypto/Kconfig b/arch/mips/crypto/Kconfig
index 9db1fd6d9f0e096765aafc108f3a0b13c60fce9d..6bf073ae7613f544ac73bd098fa1c2b64aed357f 100644 (file)
--- a/arch/mips/crypto/Kconfig
+++ b/arch/mips/crypto/Kconfig
@@ -22,16 +22,6 @@ config CRYPTO_SHA1_OCTEON
 
          Architecture: mips OCTEON
 
-config CRYPTO_SHA256_OCTEON
-       tristate "Hash functions: SHA-224 and SHA-256 (OCTEON)"
-       depends on CPU_CAVIUM_OCTEON
-       select CRYPTO_SHA256
-       select CRYPTO_HASH
-       help
-         SHA-224 and SHA-256 secure hash algorithms (FIPS 180)
-
-         Architecture: mips OCTEON using crypto instructions, when available
-
 config CRYPTO_SHA512_OCTEON
        tristate "Hash functions: SHA-384 and SHA-512 (OCTEON)"
        depends on CPU_CAVIUM_OCTEON