crypto: x86/serpent-avx,avx2 - convert to skcipher interface

Convert the AVX and AVX2 implementations of Serpent from the
(deprecated) ablkcipher and blkcipher interfaces over to the skcipher
interface.  Note that this includes replacing the use of ablk_helper
with crypto_simd.

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

diff --git a/arch/x86/crypto/serpent_avx2_glue.c b/arch/x86/crypto/serpent_avx2_glue.c
index 2bd0f0459db4313b94582fc676d43b94fa6d0c24..03347b16ac9d6c2d531a8f36af3c47c4a5f57efa 100644 (file)
--- a/arch/x86/crypto/serpent_avx2_glue.c
+++ b/arch/x86/crypto/serpent_avx2_glue.c
@@ -14,15 +14,12 @@
 #include <linux/types.h>
 #include <linux/crypto.h>
 #include <linux/err.h>
-#include <crypto/ablk_helper.h>
 #include <crypto/algapi.h>
-#include <crypto/ctr.h>
-#include <crypto/lrw.h>
-#include <crypto/xts.h>
+#include <crypto/internal/simd.h>
 #include <crypto/serpent.h>
-#include <asm/fpu/api.h>
-#include <asm/crypto/serpent-avx.h>
+#include <crypto/xts.h>
 #include <asm/crypto/glue_helper.h>
+#include <asm/crypto/serpent-avx.h>
 
 #define SERPENT_AVX2_PARALLEL_BLOCKS 16
 
@@ -40,6 +37,12 @@ asmlinkage void serpent_xts_enc_16way(struct serpent_ctx *ctx, u8 *dst,
 asmlinkage void serpent_xts_dec_16way(struct serpent_ctx *ctx, u8 *dst,
                                      const u8 *src, le128 *iv);
 
+static int serpent_setkey_skcipher(struct crypto_skcipher *tfm,
+                                  const u8 *key, unsigned int keylen)
+{
+       return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen);
+}
+
 static const struct common_glue_ctx serpent_enc = {
        .num_funcs = 3,
        .fpu_blocks_limit = 8,
@@ -136,229 +139,113 @@ static const struct common_glue_ctx serpent_dec_xts = {
        } }
 };
 
-static int ecb_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int ecb_encrypt(struct skcipher_request *req)
 {
-       return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes);
+       return glue_ecb_req_128bit(&serpent_enc, req);
 }
 
-static int ecb_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int ecb_decrypt(struct skcipher_request *req)
 {
-       return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes);
+       return glue_ecb_req_128bit(&serpent_dec, req);
 }
 
-static int cbc_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int cbc_encrypt(struct skcipher_request *req)
 {
-       return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc,
-                                      dst, src, nbytes);
+       return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__serpent_encrypt),
+                                          req);
 }
 
-static int cbc_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int cbc_decrypt(struct skcipher_request *req)
 {
-       return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src,
-                                      nbytes);
+       return glue_cbc_decrypt_req_128bit(&serpent_dec_cbc, req);
 }
 
-static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                    struct scatterlist *src, unsigned int nbytes)
+static int ctr_crypt(struct skcipher_request *req)
 {
-       return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes);
+       return glue_ctr_req_128bit(&serpent_ctr, req);
 }
 
-static int xts_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int xts_encrypt(struct skcipher_request *req)
 {
-       struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
+       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
 
-       return glue_xts_crypt_128bit(&serpent_enc_xts, desc, dst, src, nbytes,
-                                    XTS_TWEAK_CAST(__serpent_encrypt),
-                                    &ctx->tweak_ctx, &ctx->crypt_ctx);
+       return glue_xts_req_128bit(&serpent_enc_xts, req,
+                                  XTS_TWEAK_CAST(__serpent_encrypt),
+                                  &ctx->tweak_ctx, &ctx->crypt_ctx);
 }
 
-static int xts_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int xts_decrypt(struct skcipher_request *req)
 {
-       struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
+       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
 
-       return glue_xts_crypt_128bit(&serpent_dec_xts, desc, dst, src, nbytes,
-                                    XTS_TWEAK_CAST(__serpent_encrypt),
-                                    &ctx->tweak_ctx, &ctx->crypt_ctx);
+       return glue_xts_req_128bit(&serpent_dec_xts, req,
+                                  XTS_TWEAK_CAST(__serpent_encrypt),
+                                  &ctx->tweak_ctx, &ctx->crypt_ctx);
 }
 
-static struct crypto_alg srp_algs[] = { {
-       .cra_name               = "__ecb-serpent-avx2",
-       .cra_driver_name        = "__driver-ecb-serpent-avx2",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct serpent_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .setkey         = serpent_setkey,
-                       .encrypt        = ecb_encrypt,
-                       .decrypt        = ecb_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "__cbc-serpent-avx2",
-       .cra_driver_name        = "__driver-cbc-serpent-avx2",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct serpent_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .setkey         = serpent_setkey,
-                       .encrypt        = cbc_encrypt,
-                       .decrypt        = cbc_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "__ctr-serpent-avx2",
-       .cra_driver_name        = "__driver-ctr-serpent-avx2",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = 1,
-       .cra_ctxsize            = sizeof(struct serpent_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = serpent_setkey,
-                       .encrypt        = ctr_crypt,
-                       .decrypt        = ctr_crypt,
-               },
-       },
-}, {
-       .cra_name               = "__xts-serpent-avx2",
-       .cra_driver_name        = "__driver-xts-serpent-avx2",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct serpent_xts_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE * 2,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE * 2,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = xts_serpent_setkey,
-                       .encrypt        = xts_encrypt,
-                       .decrypt        = xts_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "ecb(serpent)",
-       .cra_driver_name        = "ecb-serpent-avx2",
-       .cra_priority           = 600,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = ablk_encrypt,
-                       .decrypt        = ablk_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "cbc(serpent)",
-       .cra_driver_name        = "cbc-serpent-avx2",
-       .cra_priority           = 600,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = __ablk_encrypt,
-                       .decrypt        = ablk_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "ctr(serpent)",
-       .cra_driver_name        = "ctr-serpent-avx2",
-       .cra_priority           = 600,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = 1,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = ablk_encrypt,
-                       .decrypt        = ablk_encrypt,
-                       .geniv          = "chainiv",
-               },
-       },
-}, {
-       .cra_name               = "xts(serpent)",
-       .cra_driver_name        = "xts-serpent-avx2",
-       .cra_priority           = 600,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE * 2,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE * 2,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = ablk_encrypt,
-                       .decrypt        = ablk_decrypt,
-               },
+static struct skcipher_alg serpent_algs[] = {
+       {
+               .base.cra_name          = "__ecb(serpent)",
+               .base.cra_driver_name   = "__ecb-serpent-avx2",
+               .base.cra_priority      = 600,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
+               .base.cra_ctxsize       = sizeof(struct serpent_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = SERPENT_MAX_KEY_SIZE,
+               .setkey                 = serpent_setkey_skcipher,
+               .encrypt                = ecb_encrypt,
+               .decrypt                = ecb_decrypt,
+       }, {
+               .base.cra_name          = "__cbc(serpent)",
+               .base.cra_driver_name   = "__cbc-serpent-avx2",
+               .base.cra_priority      = 600,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
+               .base.cra_ctxsize       = sizeof(struct serpent_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = SERPENT_MAX_KEY_SIZE,
+               .ivsize                 = SERPENT_BLOCK_SIZE,
+               .setkey                 = serpent_setkey_skcipher,
+               .encrypt                = cbc_encrypt,
+               .decrypt                = cbc_decrypt,
+       }, {
+               .base.cra_name          = "__ctr(serpent)",
+               .base.cra_driver_name   = "__ctr-serpent-avx2",
+               .base.cra_priority      = 600,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = 1,
+               .base.cra_ctxsize       = sizeof(struct serpent_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = SERPENT_MAX_KEY_SIZE,
+               .ivsize                 = SERPENT_BLOCK_SIZE,
+               .chunksize              = SERPENT_BLOCK_SIZE,
+               .setkey                 = serpent_setkey_skcipher,
+               .encrypt                = ctr_crypt,
+               .decrypt                = ctr_crypt,
+       }, {
+               .base.cra_name          = "__xts(serpent)",
+               .base.cra_driver_name   = "__xts-serpent-avx2",
+               .base.cra_priority      = 600,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
+               .base.cra_ctxsize       = sizeof(struct serpent_xts_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = 2 * SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = 2 * SERPENT_MAX_KEY_SIZE,
+               .ivsize                 = SERPENT_BLOCK_SIZE,
+               .setkey                 = xts_serpent_setkey,
+               .encrypt                = xts_encrypt,
+               .decrypt                = xts_decrypt,
        },
-} };
+};
+
+static struct simd_skcipher_alg *serpent_simd_algs[ARRAY_SIZE(serpent_algs)];
 
 static int __init init(void)
 {
@@ -374,12 +261,15 @@ static int __init init(void)
                return -ENODEV;
        }
 
-       return crypto_register_algs(srp_algs, ARRAY_SIZE(srp_algs));
+       return simd_register_skciphers_compat(serpent_algs,
+                                             ARRAY_SIZE(serpent_algs),
+                                             serpent_simd_algs);
 }
 
 static void __exit fini(void)
 {
-       crypto_unregister_algs(srp_algs, ARRAY_SIZE(srp_algs));
+       simd_unregister_skciphers(serpent_algs, ARRAY_SIZE(serpent_algs),
+                                 serpent_simd_algs);
 }
 
 module_init(init);

diff --git a/arch/x86/crypto/serpent_avx_glue.c b/arch/x86/crypto/serpent_avx_glue.c
index 494cfa4382e04f8e86bf559f2bbe009b398df9c2..458567ecf76c2e47e099ff840804d7eb3180b5bb 100644 (file)
--- a/arch/x86/crypto/serpent_avx_glue.c
+++ b/arch/x86/crypto/serpent_avx_glue.c
@@ -24,20 +24,15 @@
  */
 
 #include <linux/module.h>
-#include <linux/hardirq.h>
 #include <linux/types.h>
 #include <linux/crypto.h>
 #include <linux/err.h>
-#include <crypto/ablk_helper.h>
 #include <crypto/algapi.h>
+#include <crypto/internal/simd.h>
 #include <crypto/serpent.h>
-#include <crypto/cryptd.h>
-#include <crypto/b128ops.h>
-#include <crypto/ctr.h>
 #include <crypto/xts.h>
-#include <asm/fpu/api.h>
-#include <asm/crypto/serpent-avx.h>
 #include <asm/crypto/glue_helper.h>
+#include <asm/crypto/serpent-avx.h>
 
 /* 8-way parallel cipher functions */
 asmlinkage void serpent_ecb_enc_8way_avx(struct serpent_ctx *ctx, u8 *dst,
@@ -90,6 +85,31 @@ void serpent_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv)
 }
 EXPORT_SYMBOL_GPL(serpent_xts_dec);
 
+static int serpent_setkey_skcipher(struct crypto_skcipher *tfm,
+                                  const u8 *key, unsigned int keylen)
+{
+       return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen);
+}
+
+int xts_serpent_setkey(struct crypto_skcipher *tfm, const u8 *key,
+                      unsigned int keylen)
+{
+       struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
+       int err;
+
+       err = xts_verify_key(tfm, key, keylen);
+       if (err)
+               return err;
+
+       /* first half of xts-key is for crypt */
+       err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2);
+       if (err)
+               return err;
+
+       /* second half of xts-key is for tweak */
+       return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2);
+}
+EXPORT_SYMBOL_GPL(xts_serpent_setkey);
 
 static const struct common_glue_ctx serpent_enc = {
        .num_funcs = 2,
@@ -169,249 +189,113 @@ static const struct common_glue_ctx serpent_dec_xts = {
        } }
 };
 
-static int ecb_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
-{
-       return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes);
-}
-
-static int ecb_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int ecb_encrypt(struct skcipher_request *req)
 {
-       return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes);
+       return glue_ecb_req_128bit(&serpent_enc, req);
 }
 
-static int cbc_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int ecb_decrypt(struct skcipher_request *req)
 {
-       return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc,
-                                    dst, src, nbytes);
+       return glue_ecb_req_128bit(&serpent_dec, req);
 }
 
-static int cbc_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int cbc_encrypt(struct skcipher_request *req)
 {
-       return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src,
-                                      nbytes);
+       return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__serpent_encrypt),
+                                          req);
 }
 
-static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                    struct scatterlist *src, unsigned int nbytes)
+static int cbc_decrypt(struct skcipher_request *req)
 {
-       return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes);
+       return glue_cbc_decrypt_req_128bit(&serpent_dec_cbc, req);
 }
 
-int xts_serpent_setkey(struct crypto_tfm *tfm, const u8 *key,
-                      unsigned int keylen)
+static int ctr_crypt(struct skcipher_request *req)
 {
-       struct serpent_xts_ctx *ctx = crypto_tfm_ctx(tfm);
-       int err;
-
-       err = xts_check_key(tfm, key, keylen);
-       if (err)
-               return err;
-
-       /* first half of xts-key is for crypt */
-       err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2);
-       if (err)
-               return err;
-
-       /* second half of xts-key is for tweak */
-       return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2);
+       return glue_ctr_req_128bit(&serpent_ctr, req);
 }
-EXPORT_SYMBOL_GPL(xts_serpent_setkey);
 
-static int xts_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int xts_encrypt(struct skcipher_request *req)
 {
-       struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
+       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
 
-       return glue_xts_crypt_128bit(&serpent_enc_xts, desc, dst, src, nbytes,
-                                    XTS_TWEAK_CAST(__serpent_encrypt),
-                                    &ctx->tweak_ctx, &ctx->crypt_ctx);
+       return glue_xts_req_128bit(&serpent_enc_xts, req,
+                                  XTS_TWEAK_CAST(__serpent_encrypt),
+                                  &ctx->tweak_ctx, &ctx->crypt_ctx);
 }
 
-static int xts_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int xts_decrypt(struct skcipher_request *req)
 {
-       struct serpent_xts_ctx *ctx = crypto_blkcipher_ctx(desc->tfm);
+       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct serpent_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
 
-       return glue_xts_crypt_128bit(&serpent_dec_xts, desc, dst, src, nbytes,
-                                    XTS_TWEAK_CAST(__serpent_encrypt),
-                                    &ctx->tweak_ctx, &ctx->crypt_ctx);
+       return glue_xts_req_128bit(&serpent_dec_xts, req,
+                                  XTS_TWEAK_CAST(__serpent_encrypt),
+                                  &ctx->tweak_ctx, &ctx->crypt_ctx);
 }
 
-static struct crypto_alg serpent_algs[] = { {
-       .cra_name               = "__ecb-serpent-avx",
-       .cra_driver_name        = "__driver-ecb-serpent-avx",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct serpent_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .setkey         = serpent_setkey,
-                       .encrypt        = ecb_encrypt,
-                       .decrypt        = ecb_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "__cbc-serpent-avx",
-       .cra_driver_name        = "__driver-cbc-serpent-avx",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct serpent_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .setkey         = serpent_setkey,
-                       .encrypt        = cbc_encrypt,
-                       .decrypt        = cbc_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "__ctr-serpent-avx",
-       .cra_driver_name        = "__driver-ctr-serpent-avx",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = 1,
-       .cra_ctxsize            = sizeof(struct serpent_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = serpent_setkey,
-                       .encrypt        = ctr_crypt,
-                       .decrypt        = ctr_crypt,
-               },
-       },
-}, {
-       .cra_name               = "__xts-serpent-avx",
-       .cra_driver_name        = "__driver-xts-serpent-avx",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct serpent_xts_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE * 2,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE * 2,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = xts_serpent_setkey,
-                       .encrypt        = xts_encrypt,
-                       .decrypt        = xts_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "ecb(serpent)",
-       .cra_driver_name        = "ecb-serpent-avx",
-       .cra_priority           = 500,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = ablk_encrypt,
-                       .decrypt        = ablk_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "cbc(serpent)",
-       .cra_driver_name        = "cbc-serpent-avx",
-       .cra_priority           = 500,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = __ablk_encrypt,
-                       .decrypt        = ablk_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "ctr(serpent)",
-       .cra_driver_name        = "ctr-serpent-avx",
-       .cra_priority           = 500,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = 1,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = ablk_encrypt,
-                       .decrypt        = ablk_encrypt,
-                       .geniv          = "chainiv",
-               },
-       },
-}, {
-       .cra_name               = "xts(serpent)",
-       .cra_driver_name        = "xts-serpent-avx",
-       .cra_priority           = 500,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE * 2,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE * 2,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = ablk_encrypt,
-                       .decrypt        = ablk_decrypt,
-               },
+static struct skcipher_alg serpent_algs[] = {
+       {
+               .base.cra_name          = "__ecb(serpent)",
+               .base.cra_driver_name   = "__ecb-serpent-avx",
+               .base.cra_priority      = 500,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
+               .base.cra_ctxsize       = sizeof(struct serpent_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = SERPENT_MAX_KEY_SIZE,
+               .setkey                 = serpent_setkey_skcipher,
+               .encrypt                = ecb_encrypt,
+               .decrypt                = ecb_decrypt,
+       }, {
+               .base.cra_name          = "__cbc(serpent)",
+               .base.cra_driver_name   = "__cbc-serpent-avx",
+               .base.cra_priority      = 500,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
+               .base.cra_ctxsize       = sizeof(struct serpent_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = SERPENT_MAX_KEY_SIZE,
+               .ivsize                 = SERPENT_BLOCK_SIZE,
+               .setkey                 = serpent_setkey_skcipher,
+               .encrypt                = cbc_encrypt,
+               .decrypt                = cbc_decrypt,
+       }, {
+               .base.cra_name          = "__ctr(serpent)",
+               .base.cra_driver_name   = "__ctr-serpent-avx",
+               .base.cra_priority      = 500,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = 1,
+               .base.cra_ctxsize       = sizeof(struct serpent_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = SERPENT_MAX_KEY_SIZE,
+               .ivsize                 = SERPENT_BLOCK_SIZE,
+               .chunksize              = SERPENT_BLOCK_SIZE,
+               .setkey                 = serpent_setkey_skcipher,
+               .encrypt                = ctr_crypt,
+               .decrypt                = ctr_crypt,
+       }, {
+               .base.cra_name          = "__xts(serpent)",
+               .base.cra_driver_name   = "__xts-serpent-avx",
+               .base.cra_priority      = 500,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
+               .base.cra_ctxsize       = sizeof(struct serpent_xts_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = 2 * SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = 2 * SERPENT_MAX_KEY_SIZE,
+               .ivsize                 = SERPENT_BLOCK_SIZE,
+               .setkey                 = xts_serpent_setkey,
+               .encrypt                = xts_encrypt,
+               .decrypt                = xts_decrypt,
        },
-} };
+};
+
+static struct simd_skcipher_alg *serpent_simd_algs[ARRAY_SIZE(serpent_algs)];
 
 static int __init serpent_init(void)
 {
@@ -423,12 +307,15 @@ static int __init serpent_init(void)
                return -ENODEV;
        }
 
-       return crypto_register_algs(serpent_algs, ARRAY_SIZE(serpent_algs));
+       return simd_register_skciphers_compat(serpent_algs,
+                                             ARRAY_SIZE(serpent_algs),
+                                             serpent_simd_algs);
 }
 
 static void __exit serpent_exit(void)
 {
-       crypto_unregister_algs(serpent_algs, ARRAY_SIZE(serpent_algs));
+       simd_unregister_skciphers(serpent_algs, ARRAY_SIZE(serpent_algs),
+                                 serpent_simd_algs);
 }
 
 module_init(serpent_init);

diff --git a/arch/x86/include/asm/crypto/serpent-avx.h b/arch/x86/include/asm/crypto/serpent-avx.h
index 527e5edd0404f058f67bfbe0f01c632c95625f47..db7c9cc32234230ec2b3cbc291f0ea2211b0a5d2 100644 (file)
--- a/arch/x86/include/asm/crypto/serpent-avx.h
+++ b/arch/x86/include/asm/crypto/serpent-avx.h
@@ -2,8 +2,11 @@
 #ifndef ASM_X86_SERPENT_AVX_H
 #define ASM_X86_SERPENT_AVX_H
 
-#include <linux/crypto.h>
+#include <crypto/b128ops.h>
 #include <crypto/serpent.h>
+#include <linux/types.h>
+
+struct crypto_skcipher;
 
 #define SERPENT_PARALLEL_BLOCKS 8
 
@@ -33,7 +36,7 @@ extern void __serpent_crypt_ctr(void *ctx, u128 *dst, const u128 *src,
 extern void serpent_xts_enc(void *ctx, u128 *dst, const u128 *src, le128 *iv);
 extern void serpent_xts_dec(void *ctx, u128 *dst, const u128 *src, le128 *iv);
 
-extern int xts_serpent_setkey(struct crypto_tfm *tfm, const u8 *key,
+extern int xts_serpent_setkey(struct crypto_skcipher *tfm, const u8 *key,
                              unsigned int keylen);
 
 #endif

diff --git a/crypto/Kconfig b/crypto/Kconfig
index 65012ebec0ab9ebb8c8789ad5787bba64cdcff8b..cca8271d8894ddc3ef9285ea63026e1080a89734 100644 (file)
--- a/crypto/Kconfig
+++ b/crypto/Kconfig
@@ -1460,11 +1460,10 @@ config CRYPTO_SERPENT_SSE2_586
 config CRYPTO_SERPENT_AVX_X86_64
        tristate "Serpent cipher algorithm (x86_64/AVX)"
        depends on X86 && 64BIT
-       select CRYPTO_ALGAPI
-       select CRYPTO_CRYPTD
-       select CRYPTO_ABLK_HELPER
+       select CRYPTO_BLKCIPHER
        select CRYPTO_GLUE_HELPER_X86
        select CRYPTO_SERPENT
+       select CRYPTO_SIMD
        select CRYPTO_XTS
        help
          Serpent cipher algorithm, by Anderson, Biham & Knudsen.
@@ -1481,13 +1480,7 @@ config CRYPTO_SERPENT_AVX_X86_64
 config CRYPTO_SERPENT_AVX2_X86_64
        tristate "Serpent cipher algorithm (x86_64/AVX2)"
        depends on X86 && 64BIT
-       select CRYPTO_ALGAPI
-       select CRYPTO_CRYPTD
-       select CRYPTO_ABLK_HELPER
-       select CRYPTO_GLUE_HELPER_X86
-       select CRYPTO_SERPENT
        select CRYPTO_SERPENT_AVX_X86_64
-       select CRYPTO_XTS
        help
          Serpent cipher algorithm, by Anderson, Biham & Knudsen.