n2_crypto: Plumb fallback ahash requests properly.
authorDavid S. Miller <davem@davemloft.net>
Sat, 22 May 2010 08:09:04 +0000 (01:09 -0700)
committerDavid S. Miller <davem@davemloft.net>
Wed, 26 May 2010 00:37:15 +0000 (17:37 -0700)
Do this by putting the async fallback request at the end of an n2
specific ahash request context, then properly adjusting the request
private size in our ahash ->cra_init().

We also need to put the writable state bits into the n2 request
private instead of the n2 cra_ctx.

With help from Herbert Xu.

Signed-off-by: David S. Miller <davem@davemloft.net>
drivers/crypto/n2_core.c

index 5613b8affe11424295a51bbc9edfe02afc55afce..23163fda5035357a50c892c1a65a35e7ae3a89ea 100644 (file)
@@ -251,16 +251,10 @@ static void n2_base_ctx_init(struct n2_base_ctx *ctx)
 struct n2_hash_ctx {
        struct n2_base_ctx              base;
 
-       struct crypto_ahash             *fallback;
+       struct crypto_ahash             *fallback_tfm;
+};
 
-       /* These next three members must match the layout created by
-        * crypto_init_shash_ops_async.  This allows us to properly
-        * plumb requests we can't do in hardware down to the fallback
-        * operation, providing all of the data structures and layouts
-        * expected by those paths.
-        */
-       struct ahash_request            fallback_req;
-       struct shash_desc               fallback_desc;
+struct n2_hash_req_ctx {
        union {
                struct md5_state        md5;
                struct sha1_state       sha1;
@@ -269,56 +263,62 @@ struct n2_hash_ctx {
 
        unsigned char                   hash_key[64];
        unsigned char                   keyed_zero_hash[32];
+
+       struct ahash_request            fallback_req;
 };
 
 static int n2_hash_async_init(struct ahash_request *req)
 {
+       struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
        struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
        struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
 
-       ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback);
-       ctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
+       ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
+       rctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
 
-       return crypto_ahash_init(&ctx->fallback_req);
+       return crypto_ahash_init(&rctx->fallback_req);
 }
 
 static int n2_hash_async_update(struct ahash_request *req)
 {
+       struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
        struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
        struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
 
-       ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback);
-       ctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
-       ctx->fallback_req.nbytes = req->nbytes;
-       ctx->fallback_req.src = req->src;
+       ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
+       rctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
+       rctx->fallback_req.nbytes = req->nbytes;
+       rctx->fallback_req.src = req->src;
 
-       return crypto_ahash_update(&ctx->fallback_req);
+       return crypto_ahash_update(&rctx->fallback_req);
 }
 
 static int n2_hash_async_final(struct ahash_request *req)
 {
+       struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
        struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
        struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
 
-       ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback);
-       ctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
-       ctx->fallback_req.result = req->result;
+       ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
+       rctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
+       rctx->fallback_req.result = req->result;
 
-       return crypto_ahash_final(&ctx->fallback_req);
+       return crypto_ahash_final(&rctx->fallback_req);
 }
 
 static int n2_hash_async_finup(struct ahash_request *req)
 {
+       struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
        struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
        struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
 
-       ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback);
-       ctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
-       ctx->fallback_req.nbytes = req->nbytes;
-       ctx->fallback_req.src = req->src;
-       ctx->fallback_req.result = req->result;
+       ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
+       rctx->fallback_req.base.flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
+       rctx->fallback_req.nbytes = req->nbytes;
+       rctx->fallback_req.src = req->src;
+       rctx->fallback_req.result = req->result;
 
-       return crypto_ahash_finup(&ctx->fallback_req);
+       return crypto_ahash_finup(&rctx->fallback_req);
 }
 
 static int n2_hash_cra_init(struct crypto_tfm *tfm)
@@ -338,7 +338,10 @@ static int n2_hash_cra_init(struct crypto_tfm *tfm)
                goto out;
        }
 
-       ctx->fallback = fallback_tfm;
+       crypto_ahash_set_reqsize(ahash, (sizeof(struct n2_hash_req_ctx) +
+                                        crypto_ahash_reqsize(fallback_tfm)));
+
+       ctx->fallback_tfm = fallback_tfm;
        return 0;
 
 out:
@@ -350,7 +353,7 @@ static void n2_hash_cra_exit(struct crypto_tfm *tfm)
        struct crypto_ahash *ahash = __crypto_ahash_cast(tfm);
        struct n2_hash_ctx *ctx = crypto_ahash_ctx(ahash);
 
-       crypto_free_ahash(ctx->fallback);
+       crypto_free_ahash(ctx->fallback_tfm);
 }
 
 static unsigned long wait_for_tail(struct spu_queue *qp)
@@ -399,14 +402,16 @@ static int n2_hash_async_digest(struct ahash_request *req,
         * exceed 2^16.
         */
        if (unlikely(req->nbytes > (1 << 16))) {
-               ctx->fallback_req.base.tfm = crypto_ahash_tfm(ctx->fallback);
-               ctx->fallback_req.base.flags =
+               struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
+
+               ahash_request_set_tfm(&rctx->fallback_req, ctx->fallback_tfm);
+               rctx->fallback_req.base.flags =
                        req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP;
-               ctx->fallback_req.nbytes = req->nbytes;
-               ctx->fallback_req.src = req->src;
-               ctx->fallback_req.result = req->result;
+               rctx->fallback_req.nbytes = req->nbytes;
+               rctx->fallback_req.src = req->src;
+               rctx->fallback_req.result = req->result;
 
-               return crypto_ahash_digest(&ctx->fallback_req);
+               return crypto_ahash_digest(&rctx->fallback_req);
        }
 
        n2_base_ctx_init(&ctx->base);
@@ -472,9 +477,8 @@ out:
 
 static int n2_md5_async_digest(struct ahash_request *req)
 {
-       struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
-       struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
-       struct md5_state *m = &ctx->u.md5;
+       struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
+       struct md5_state *m = &rctx->u.md5;
 
        if (unlikely(req->nbytes == 0)) {
                static const char md5_zero[MD5_DIGEST_SIZE] = {
@@ -497,9 +501,8 @@ static int n2_md5_async_digest(struct ahash_request *req)
 
 static int n2_sha1_async_digest(struct ahash_request *req)
 {
-       struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
-       struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
-       struct sha1_state *s = &ctx->u.sha1;
+       struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
+       struct sha1_state *s = &rctx->u.sha1;
 
        if (unlikely(req->nbytes == 0)) {
                static const char sha1_zero[SHA1_DIGEST_SIZE] = {
@@ -524,9 +527,8 @@ static int n2_sha1_async_digest(struct ahash_request *req)
 
 static int n2_sha256_async_digest(struct ahash_request *req)
 {
-       struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
-       struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
-       struct sha256_state *s = &ctx->u.sha256;
+       struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
+       struct sha256_state *s = &rctx->u.sha256;
 
        if (req->nbytes == 0) {
                static const char sha256_zero[SHA256_DIGEST_SIZE] = {
@@ -555,9 +557,8 @@ static int n2_sha256_async_digest(struct ahash_request *req)
 
 static int n2_sha224_async_digest(struct ahash_request *req)
 {
-       struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
-       struct n2_hash_ctx *ctx = crypto_ahash_ctx(tfm);
-       struct sha256_state *s = &ctx->u.sha256;
+       struct n2_hash_req_ctx *rctx = ahash_request_ctx(req);
+       struct sha256_state *s = &rctx->u.sha256;
 
        if (req->nbytes == 0) {
                static const char sha224_zero[SHA224_DIGEST_SIZE] = {