mm: use pagevec_lookup_range_tag() in __filemap_fdatawait_range()

[sfrench/cifs-2.6.git] / crypto / gcm.c

diff --git a/crypto/gcm.c b/crypto/gcm.c
index 3841b5eafa7ee244f605c28fd56c5a8c5dcaba9b..8589681fb9f6d3b522894af6d9bc048a17d93cd2 100644 (file)
--- a/crypto/gcm.c
+++ b/crypto/gcm.c
@@ -14,9 +14,9 @@
 #include <crypto/internal/hash.h>
 #include <crypto/null.h>
 #include <crypto/scatterwalk.h>
+#include <crypto/gcm.h>
 #include <crypto/hash.h>
 #include "internal.h"
-#include <linux/completion.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
@@ -78,11 +78,6 @@ struct crypto_gcm_req_priv_ctx {
        } u;
 };
 
-struct crypto_gcm_setkey_result {
-       int err;
-       struct completion completion;
-};
-
 static struct {
        u8 buf[16];
        struct scatterlist sg;
@@ -98,17 +93,6 @@ static inline struct crypto_gcm_req_priv_ctx *crypto_gcm_reqctx(
        return (void *)PTR_ALIGN((u8 *)aead_request_ctx(req), align + 1);
 }
 
-static void crypto_gcm_setkey_done(struct crypto_async_request *req, int err)
-{
-       struct crypto_gcm_setkey_result *result = req->data;
-
-       if (err == -EINPROGRESS)
-               return;
-
-       result->err = err;
-       complete(&result->completion);
-}
-
 static int crypto_gcm_setkey(struct crypto_aead *aead, const u8 *key,
                             unsigned int keylen)
 {
@@ -119,7 +103,7 @@ static int crypto_gcm_setkey(struct crypto_aead *aead, const u8 *key,
                be128 hash;
                u8 iv[16];
 
-               struct crypto_gcm_setkey_result result;
+               struct crypto_wait wait;
 
                struct scatterlist sg[1];
                struct skcipher_request req;
@@ -140,21 +124,18 @@ static int crypto_gcm_setkey(struct crypto_aead *aead, const u8 *key,
        if (!data)
                return -ENOMEM;
 
-       init_completion(&data->result.completion);
+       crypto_init_wait(&data->wait);
        sg_init_one(data->sg, &data->hash, sizeof(data->hash));
        skcipher_request_set_tfm(&data->req, ctr);
        skcipher_request_set_callback(&data->req, CRYPTO_TFM_REQ_MAY_SLEEP |
                                                  CRYPTO_TFM_REQ_MAY_BACKLOG,
-                                     crypto_gcm_setkey_done,
-                                     &data->result);
+                                     crypto_req_done,
+                                     &data->wait);
        skcipher_request_set_crypt(&data->req, data->sg, data->sg,
                                   sizeof(data->hash), data->iv);
 
-       err = crypto_skcipher_encrypt(&data->req);
-       if (err == -EINPROGRESS || err == -EBUSY) {
-               wait_for_completion(&data->result.completion);
-               err = data->result.err;
-       }
+       err = crypto_wait_req(crypto_skcipher_encrypt(&data->req),
+                                                       &data->wait);
 
        if (err)
                goto out;
@@ -197,8 +178,8 @@ static void crypto_gcm_init_common(struct aead_request *req)
        struct scatterlist *sg;
 
        memset(pctx->auth_tag, 0, sizeof(pctx->auth_tag));
-       memcpy(pctx->iv, req->iv, 12);
-       memcpy(pctx->iv + 12, &counter, 4);
+       memcpy(pctx->iv, req->iv, GCM_AES_IV_SIZE);
+       memcpy(pctx->iv + GCM_AES_IV_SIZE, &counter, 4);
 
        sg_init_table(pctx->src, 3);
        sg_set_buf(pctx->src, pctx->auth_tag, sizeof(pctx->auth_tag));
@@ -695,7 +676,7 @@ static int crypto_gcm_create_common(struct crypto_template *tmpl,
        inst->alg.base.cra_alignmask = ghash->base.cra_alignmask |
                                       ctr->base.cra_alignmask;
        inst->alg.base.cra_ctxsize = sizeof(struct crypto_gcm_ctx);
-       inst->alg.ivsize = 12;
+       inst->alg.ivsize = GCM_AES_IV_SIZE;
        inst->alg.chunksize = crypto_skcipher_alg_chunksize(ctr);
        inst->alg.maxauthsize = 16;
        inst->alg.init = crypto_gcm_init_tfm;
@@ -832,20 +813,20 @@ static struct aead_request *crypto_rfc4106_crypt(struct aead_request *req)
        u8 *iv = PTR_ALIGN((u8 *)(subreq + 1) + crypto_aead_reqsize(child),
                           crypto_aead_alignmask(child) + 1);
 
-       scatterwalk_map_and_copy(iv + 12, req->src, 0, req->assoclen - 8, 0);
+       scatterwalk_map_and_copy(iv + GCM_AES_IV_SIZE, req->src, 0, req->assoclen - 8, 0);
 
        memcpy(iv, ctx->nonce, 4);
        memcpy(iv + 4, req->iv, 8);
 
        sg_init_table(rctx->src, 3);
-       sg_set_buf(rctx->src, iv + 12, req->assoclen - 8);
+       sg_set_buf(rctx->src, iv + GCM_AES_IV_SIZE, req->assoclen - 8);
        sg = scatterwalk_ffwd(rctx->src + 1, req->src, req->assoclen);
        if (sg != rctx->src + 1)
                sg_chain(rctx->src, 2, sg);
 
        if (req->src != req->dst) {
                sg_init_table(rctx->dst, 3);
-               sg_set_buf(rctx->dst, iv + 12, req->assoclen - 8);
+               sg_set_buf(rctx->dst, iv + GCM_AES_IV_SIZE, req->assoclen - 8);
                sg = scatterwalk_ffwd(rctx->dst + 1, req->dst, req->assoclen);
                if (sg != rctx->dst + 1)
                        sg_chain(rctx->dst, 2, sg);
@@ -957,7 +938,7 @@ static int crypto_rfc4106_create(struct crypto_template *tmpl,
        err = -EINVAL;
 
        /* Underlying IV size must be 12. */
-       if (crypto_aead_alg_ivsize(alg) != 12)
+       if (crypto_aead_alg_ivsize(alg) != GCM_AES_IV_SIZE)
                goto out_drop_alg;
 
        /* Not a stream cipher? */
@@ -980,7 +961,7 @@ static int crypto_rfc4106_create(struct crypto_template *tmpl,
 
        inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc4106_ctx);
 
-       inst->alg.ivsize = 8;
+       inst->alg.ivsize = GCM_RFC4106_IV_SIZE;
        inst->alg.chunksize = crypto_aead_alg_chunksize(alg);
        inst->alg.maxauthsize = crypto_aead_alg_maxauthsize(alg);
 
@@ -1134,7 +1115,7 @@ static int crypto_rfc4543_init_tfm(struct crypto_aead *tfm)
                tfm,
                sizeof(struct crypto_rfc4543_req_ctx) +
                ALIGN(crypto_aead_reqsize(aead), crypto_tfm_ctx_alignment()) +
-               align + 12);
+               align + GCM_AES_IV_SIZE);
 
        return 0;
 
@@ -1199,7 +1180,7 @@ static int crypto_rfc4543_create(struct crypto_template *tmpl,
        err = -EINVAL;
 
        /* Underlying IV size must be 12. */
-       if (crypto_aead_alg_ivsize(alg) != 12)
+       if (crypto_aead_alg_ivsize(alg) != GCM_AES_IV_SIZE)
                goto out_drop_alg;
 
        /* Not a stream cipher? */
@@ -1222,7 +1203,7 @@ static int crypto_rfc4543_create(struct crypto_template *tmpl,
 
        inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc4543_ctx);
 
-       inst->alg.ivsize = 8;
+       inst->alg.ivsize = GCM_RFC4543_IV_SIZE;
        inst->alg.chunksize = crypto_aead_alg_chunksize(alg);
        inst->alg.maxauthsize = crypto_aead_alg_maxauthsize(alg);