crypto: cryptd - Switch to new style ahash

This patch changes cryptd to use the new style ahash type.  In
particular, the instance is enlarged to encapsulate the new
ahash_alg structure.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/crypto/cryptd.c b/crypto/cryptd.c
index ad58f513ba8b8d20089f7470e73c8da4859900eb..5dabb7dbad84909129578195e9647cbfd460824b 100644 (file)
--- a/crypto/cryptd.c
+++ b/crypto/cryptd.c
@@ -255,17 +255,18 @@ static void cryptd_blkcipher_exit_tfm(struct crypto_tfm *tfm)
        crypto_free_blkcipher(ctx->child);
 }
 
-static struct crypto_instance *cryptd_alloc_instance(struct crypto_alg *alg,
-                                                    unsigned int tail)
+static void *cryptd_alloc_instance(struct crypto_alg *alg, unsigned int head,
+                                  unsigned int tail)
 {
+       char *p;
        struct crypto_instance *inst;
        int err;
 
-       inst = kzalloc(sizeof(*inst) + tail, GFP_KERNEL);
-       if (!inst) {
-               inst = ERR_PTR(-ENOMEM);
-               goto out;
-       }
+       p = kzalloc(head + sizeof(*inst) + tail, GFP_KERNEL);
+       if (!p)
+               return ERR_PTR(-ENOMEM);
+
+       inst = (void *)(p + head);
 
        err = -ENAMETOOLONG;
        if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME,
@@ -279,11 +280,11 @@ static struct crypto_instance *cryptd_alloc_instance(struct crypto_alg *alg,
        inst->alg.cra_alignmask = alg->cra_alignmask;
 
 out:
-       return inst;
+       return p;
 
 out_free_inst:
-       kfree(inst);
-       inst = ERR_PTR(err);
+       kfree(p);
+       p = ERR_PTR(err);
        goto out;
 }
 
@@ -301,7 +302,7 @@ static int cryptd_create_blkcipher(struct crypto_template *tmpl,
        if (IS_ERR(alg))
                return PTR_ERR(alg);
 
-       inst = cryptd_alloc_instance(alg, sizeof(*ctx));
+       inst = cryptd_alloc_instance(alg, 0, sizeof(*ctx));
        if (IS_ERR(inst))
                goto out_put_alg;
 
@@ -509,7 +510,7 @@ static int cryptd_create_hash(struct crypto_template *tmpl, struct rtattr **tb,
                              struct cryptd_queue *queue)
 {
        struct hashd_instance_ctx *ctx;
-       struct crypto_instance *inst;
+       struct ahash_instance *inst;
        struct shash_alg *salg;
        struct crypto_alg *alg;
        int err;
@@ -519,33 +520,34 @@ static int cryptd_create_hash(struct crypto_template *tmpl, struct rtattr **tb,
                return PTR_ERR(salg);
 
        alg = &salg->base;
-       inst = cryptd_alloc_instance(alg, sizeof(*ctx));
+       inst = cryptd_alloc_instance(alg, ahash_instance_headroom(),
+                                    sizeof(*ctx));
        if (IS_ERR(inst))
                goto out_put_alg;
 
-       ctx = crypto_instance_ctx(inst);
+       ctx = ahash_instance_ctx(inst);
        ctx->queue = queue;
 
-       err = crypto_init_shash_spawn(&ctx->spawn, salg, inst);
+       err = crypto_init_shash_spawn(&ctx->spawn, salg,
+                                     ahash_crypto_instance(inst));
        if (err)
                goto out_free_inst;
 
-       inst->alg.cra_flags = CRYPTO_ALG_TYPE_AHASH | CRYPTO_ALG_ASYNC;
-       inst->alg.cra_type = &crypto_ahash_type;
+       inst->alg.halg.base.cra_flags = CRYPTO_ALG_ASYNC;
 
-       inst->alg.cra_ahash.digestsize = salg->digestsize;
-       inst->alg.cra_ctxsize = sizeof(struct cryptd_hash_ctx);
+       inst->alg.halg.digestsize = salg->digestsize;
+       inst->alg.halg.base.cra_ctxsize = sizeof(struct cryptd_hash_ctx);
 
-       inst->alg.cra_init = cryptd_hash_init_tfm;
-       inst->alg.cra_exit = cryptd_hash_exit_tfm;
+       inst->alg.halg.base.cra_init = cryptd_hash_init_tfm;
+       inst->alg.halg.base.cra_exit = cryptd_hash_exit_tfm;
 
-       inst->alg.cra_ahash.init   = cryptd_hash_init_enqueue;
-       inst->alg.cra_ahash.update = cryptd_hash_update_enqueue;
-       inst->alg.cra_ahash.final  = cryptd_hash_final_enqueue;
-       inst->alg.cra_ahash.setkey = cryptd_hash_setkey;
-       inst->alg.cra_ahash.digest = cryptd_hash_digest_enqueue;
+       inst->alg.init   = cryptd_hash_init_enqueue;
+       inst->alg.update = cryptd_hash_update_enqueue;
+       inst->alg.final  = cryptd_hash_final_enqueue;
+       inst->alg.setkey = cryptd_hash_setkey;
+       inst->alg.digest = cryptd_hash_digest_enqueue;
 
-       err = crypto_register_instance(tmpl, inst);
+       err = ahash_register_instance(tmpl, inst);
        if (err) {
                crypto_drop_shash(&ctx->spawn);
 out_free_inst:
@@ -580,6 +582,14 @@ static int cryptd_create(struct crypto_template *tmpl, struct rtattr **tb)
 static void cryptd_free(struct crypto_instance *inst)
 {
        struct cryptd_instance_ctx *ctx = crypto_instance_ctx(inst);
+       struct hashd_instance_ctx *hctx = crypto_instance_ctx(inst);
+
+       switch (inst->alg.cra_flags & CRYPTO_ALG_TYPE_MASK) {
+       case CRYPTO_ALG_TYPE_AHASH:
+               crypto_drop_shash(&hctx->spawn);
+               kfree(ahash_instance(inst));
+               return;
+       }
 
        crypto_drop_spawn(&ctx->spawn);
        kfree(inst);