Merge branch 'for-linus' of master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband

[linux-drm-fsl-dcu.git] / crypto / api.c

diff --git a/crypto/api.c b/crypto/api.c
index 4fb7fa45cb0de649194262c5f6061669b3391a80..55af8bb0f0502eb7f80f3ed2c71fb21518319252 100644 (file)
--- a/crypto/api.c
+++ b/crypto/api.c
@@ -212,31 +212,12 @@ struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask)
 }
 EXPORT_SYMBOL_GPL(crypto_alg_mod_lookup);
 
-static int crypto_init_flags(struct crypto_tfm *tfm, u32 flags)
+static int crypto_init_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
 {
-       tfm->crt_flags = flags & CRYPTO_TFM_REQ_MASK;
-       flags &= ~CRYPTO_TFM_REQ_MASK;
-       
-       switch (crypto_tfm_alg_type(tfm)) {
-       case CRYPTO_ALG_TYPE_CIPHER:
-               return crypto_init_cipher_flags(tfm, flags);
-               
-       case CRYPTO_ALG_TYPE_DIGEST:
-               return crypto_init_digest_flags(tfm, flags);
-               
-       case CRYPTO_ALG_TYPE_COMPRESS:
-               return crypto_init_compress_flags(tfm, flags);
-       }
-       
-       return 0;
-}
+       const struct crypto_type *type_obj = tfm->__crt_alg->cra_type;
 
-static int crypto_init_ops(struct crypto_tfm *tfm)
-{
-       const struct crypto_type *type = tfm->__crt_alg->cra_type;
-
-       if (type)
-               return type->init(tfm);
+       if (type_obj)
+               return type_obj->init(tfm, type, mask);
 
        switch (crypto_tfm_alg_type(tfm)) {
        case CRYPTO_ALG_TYPE_CIPHER:
@@ -285,29 +266,29 @@ static void crypto_exit_ops(struct crypto_tfm *tfm)
        }
 }
 
-static unsigned int crypto_ctxsize(struct crypto_alg *alg, int flags)
+static unsigned int crypto_ctxsize(struct crypto_alg *alg, u32 type, u32 mask)
 {
-       const struct crypto_type *type = alg->cra_type;
+       const struct crypto_type *type_obj = alg->cra_type;
        unsigned int len;
 
        len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1);
-       if (type)
-               return len + type->ctxsize(alg);
+       if (type_obj)
+               return len + type_obj->ctxsize(alg, type, mask);
 
        switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
        default:
                BUG();
 
        case CRYPTO_ALG_TYPE_CIPHER:
-               len += crypto_cipher_ctxsize(alg, flags);
+               len += crypto_cipher_ctxsize(alg);
                break;
                
        case CRYPTO_ALG_TYPE_DIGEST:
-               len += crypto_digest_ctxsize(alg, flags);
+               len += crypto_digest_ctxsize(alg);
                break;
                
        case CRYPTO_ALG_TYPE_COMPRESS:
-               len += crypto_compress_ctxsize(alg, flags);
+               len += crypto_compress_ctxsize(alg);
                break;
        }
 
@@ -322,24 +303,21 @@ void crypto_shoot_alg(struct crypto_alg *alg)
 }
 EXPORT_SYMBOL_GPL(crypto_shoot_alg);
 
-struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 flags)
+struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
+                                     u32 mask)
 {
        struct crypto_tfm *tfm = NULL;
        unsigned int tfm_size;
        int err = -ENOMEM;
 
-       tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, flags);
+       tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask);
        tfm = kzalloc(tfm_size, GFP_KERNEL);
        if (tfm == NULL)
                goto out_err;
 
        tfm->__crt_alg = alg;
 
-       err = crypto_init_flags(tfm, flags);
-       if (err)
-               goto out_free_tfm;
-               
-       err = crypto_init_ops(tfm);
+       err = crypto_init_ops(tfm, type, mask);
        if (err)
                goto out_free_tfm;
 
@@ -362,31 +340,6 @@ out:
 }
 EXPORT_SYMBOL_GPL(__crypto_alloc_tfm);
 
-struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
-{
-       struct crypto_tfm *tfm = NULL;
-       int err;
-
-       do {
-               struct crypto_alg *alg;
-
-               alg = crypto_alg_mod_lookup(name, 0, CRYPTO_ALG_ASYNC);
-               err = PTR_ERR(alg);
-               if (IS_ERR(alg))
-                       continue;
-
-               tfm = __crypto_alloc_tfm(alg, flags);
-               err = 0;
-               if (IS_ERR(tfm)) {
-                       crypto_mod_put(alg);
-                       err = PTR_ERR(tfm);
-                       tfm = NULL;
-               }
-       } while (err == -EAGAIN && !signal_pending(current));
-
-       return tfm;
-}
-
 /*
  *     crypto_alloc_base - Locate algorithm and allocate transform
  *     @alg_name: Name of algorithm
@@ -420,7 +373,7 @@ struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask)
                        goto err;
                }
 
-               tfm = __crypto_alloc_tfm(alg, 0);
+               tfm = __crypto_alloc_tfm(alg, type, mask);
                if (!IS_ERR(tfm))
                        return tfm;
 
@@ -466,23 +419,7 @@ void crypto_free_tfm(struct crypto_tfm *tfm)
        kfree(tfm);
 }
 
-int crypto_alg_available(const char *name, u32 flags)
-{
-       int ret = 0;
-       struct crypto_alg *alg = crypto_alg_mod_lookup(name, 0,
-                                                      CRYPTO_ALG_ASYNC);
-       
-       if (!IS_ERR(alg)) {
-               crypto_mod_put(alg);
-               ret = 1;
-       }
-       
-       return ret;
-}
-
-EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
 EXPORT_SYMBOL_GPL(crypto_free_tfm);
-EXPORT_SYMBOL_GPL(crypto_alg_available);
 
 int crypto_has_alg(const char *name, u32 type, u32 mask)
 {