crypto: algif - move to generic async completion

algif starts several async crypto ops and waits for their completion.
Move it over to generic code doing the same.

Signed-off-by: Gilad Ben-Yossef <gilad@benyossef.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

4 files changed, 22 insertions, 52 deletions

diff --git a/crypto/af_alg.c b/crypto/af_alg.c
index 337cf382718e..85cea9de324a 100644
--- a/crypto/af_alg.c
+++ b/crypto/af_alg.c
@@ -481,33 +481,6 @@ int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con)
 }
 EXPORT_SYMBOL_GPL(af_alg_cmsg_send);
 
-int af_alg_wait_for_completion(int err, struct af_alg_completion *completion)
-{
-        switch (err) {
-        case -EINPROGRESS:
-        case -EBUSY:
-                wait_for_completion(&completion->completion);
-                reinit_completion(&completion->completion);
-                err = completion->err;
-                break;
-        };
-
-        return err;
-}
-EXPORT_SYMBOL_GPL(af_alg_wait_for_completion);
-
-void af_alg_complete(struct crypto_async_request *req, int err)
-{
-        struct af_alg_completion *completion = req->data;
-
-        if (err == -EINPROGRESS)
-                return;
-
-        completion->err = err;
-        complete(&completion->completion);
-}
-EXPORT_SYMBOL_GPL(af_alg_complete);
-
 /**
  * af_alg_alloc_tsgl - allocate the TX SGL
  *
diff --git a/crypto/algif_aead.c b/crypto/algif_aead.c
index 516b38c3a169..aacae0837aff 100644
--- a/crypto/algif_aead.c
+++ b/crypto/algif_aead.c
@@ -278,11 +278,11 @@ static int _aead_recvmsg(struct socket *sock, struct msghdr *msg,
                 /* Synchronous operation */
                 aead_request_set_callback(&areq->cra_u.aead_req,
                                           CRYPTO_TFM_REQ_MAY_BACKLOG,
-                                          af_alg_complete, &ctx->completion);
-                err = af_alg_wait_for_completion(ctx->enc ?
+                                          crypto_req_done, &ctx->wait);
+                err = crypto_wait_req(ctx->enc ?
                                 crypto_aead_encrypt(&areq->cra_u.aead_req) :
                                 crypto_aead_decrypt(&areq->cra_u.aead_req),
-                                                 &ctx->completion);
+                                &ctx->wait);
         }
 
         /* AIO operation in progress */
@@ -554,7 +554,7 @@ static int aead_accept_parent_nokey(void *private, struct sock *sk)
         ctx->merge = 0;
         ctx->enc = 0;
         ctx->aead_assoclen = 0;
-        af_alg_init_completion(&ctx->completion);
+        crypto_init_wait(&ctx->wait);
 
         ask->private = ctx;
 
diff --git a/crypto/algif_hash.c b/crypto/algif_hash.c
index 5e92bd275ef3..76d2e716c792 100644
--- a/crypto/algif_hash.c
+++ b/crypto/algif_hash.c
@@ -26,7 +26,7 @@ struct hash_ctx {
 
         u8 *result;
 
-        struct af_alg_completion completion;
+        struct crypto_wait wait;
 
         unsigned int len;
         bool more;
@@ -88,8 +88,7 @@ static int hash_sendmsg(struct socket *sock, struct msghdr *msg,
                 if ((msg->msg_flags & MSG_MORE))
                         hash_free_result(sk, ctx);
 
-                err = af_alg_wait_for_completion(crypto_ahash_init(&ctx->req),
-                                                &ctx->completion);
+                err = crypto_wait_req(crypto_ahash_init(&ctx->req), &ctx->wait);
                 if (err)
                         goto unlock;
         }
@@ -110,8 +109,8 @@ static int hash_sendmsg(struct socket *sock, struct msghdr *msg,
 
                 ahash_request_set_crypt(&ctx->req, ctx->sgl.sg, NULL, len);
 
-                err = af_alg_wait_for_completion(crypto_ahash_update(&ctx->req),
-                                                 &ctx->completion);
+                err = crypto_wait_req(crypto_ahash_update(&ctx->req),
+                                      &ctx->wait);
                 af_alg_free_sg(&ctx->sgl);
                 if (err)
                         goto unlock;
@@ -129,8 +128,8 @@ static int hash_sendmsg(struct socket *sock, struct msghdr *msg,
                         goto unlock;
 
                 ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0);
-                err = af_alg_wait_for_completion(crypto_ahash_final(&ctx->req),
-                                                 &ctx->completion);
+                err = crypto_wait_req(crypto_ahash_final(&ctx->req),
+                                      &ctx->wait);
         }
 
 unlock:
@@ -171,7 +170,7 @@ static ssize_t hash_sendpage(struct socket *sock, struct page *page,
         } else {
                 if (!ctx->more) {
                         err = crypto_ahash_init(&ctx->req);
-                        err = af_alg_wait_for_completion(err, &ctx->completion);
+                        err = crypto_wait_req(err, &ctx->wait);
                         if (err)
                                 goto unlock;
                 }
@@ -179,7 +178,7 @@ static ssize_t hash_sendpage(struct socket *sock, struct page *page,
                 err = crypto_ahash_update(&ctx->req);
         }
 
-        err = af_alg_wait_for_completion(err, &ctx->completion);
+        err = crypto_wait_req(err, &ctx->wait);
         if (err)
                 goto unlock;
 
@@ -215,17 +214,16 @@ static int hash_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
         ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0);
 
         if (!result && !ctx->more) {
-                err = af_alg_wait_for_completion(
-                                crypto_ahash_init(&ctx->req),
-                                &ctx->completion);
+                err = crypto_wait_req(crypto_ahash_init(&ctx->req),
+                                      &ctx->wait);
                 if (err)
                         goto unlock;
         }
 
         if (!result || ctx->more) {
                 ctx->more = 0;
-                err = af_alg_wait_for_completion(crypto_ahash_final(&ctx->req),
-                                                 &ctx->completion);
+                err = crypto_wait_req(crypto_ahash_final(&ctx->req),
+                                      &ctx->wait);
                 if (err)
                         goto unlock;
         }
@@ -476,13 +474,13 @@ static int hash_accept_parent_nokey(void *private, struct sock *sk)
         ctx->result = NULL;
         ctx->len = len;
         ctx->more = 0;
-        af_alg_init_completion(&ctx->completion);
+        crypto_init_wait(&ctx->wait);
 
         ask->private = ctx;
 
         ahash_request_set_tfm(&ctx->req, hash);
         ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG,
-                                   af_alg_complete, &ctx->completion);
+                                   crypto_req_done, &ctx->wait);
 
         sk->sk_destruct = hash_sock_destruct;
 
diff --git a/crypto/algif_skcipher.c b/crypto/algif_skcipher.c
index 8ae4170aaeb4..9954b078f0b9 100644
--- a/crypto/algif_skcipher.c
+++ b/crypto/algif_skcipher.c
@@ -129,12 +129,11 @@ static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
                 skcipher_request_set_callback(&areq->cra_u.skcipher_req,
                                               CRYPTO_TFM_REQ_MAY_SLEEP |
                                               CRYPTO_TFM_REQ_MAY_BACKLOG,
-                                              af_alg_complete,
-                                              &ctx->completion);
-                err = af_alg_wait_for_completion(ctx->enc ?
+                                              crypto_req_done, &ctx->wait);
+                err = crypto_wait_req(ctx->enc ?
                         crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
                         crypto_skcipher_decrypt(&areq->cra_u.skcipher_req),
-                                                 &ctx->completion);
+                                                 &ctx->wait);
         }
 
         /* AIO operation in progress */
@@ -388,7 +387,7 @@ static int skcipher_accept_parent_nokey(void *private, struct sock *sk)
         ctx->more = 0;
         ctx->merge = 0;
         ctx->enc = 0;
-        af_alg_init_completion(&ctx->completion);
+        crypto_init_wait(&ctx->wait);
 
         ask->private = ctx;