Merge master.kernel.org:/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw

[pandora-kernel.git] / crypto / api.c

diff --git a/crypto/api.c b/crypto/api.c
index bc4b790..8c44687 100644 (file)
--- a/crypto/api.c
+++ b/crypto/api.c
@@ -226,17 +226,18 @@ static int crypto_init_flags(struct crypto_tfm *tfm, u32 flags)
                
        case CRYPTO_ALG_TYPE_COMPRESS:
                return crypto_init_compress_flags(tfm, flags);
-       
-       default:
-               break;
        }
        
-       BUG();
-       return -EINVAL;
+       return 0;
 }
 
 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);
+
        switch (crypto_tfm_alg_type(tfm)) {
        case CRYPTO_ALG_TYPE_CIPHER:
                return crypto_init_cipher_ops(tfm);
@@ -257,6 +258,14 @@ static int crypto_init_ops(struct crypto_tfm *tfm)
 
 static void crypto_exit_ops(struct crypto_tfm *tfm)
 {
+       const struct crypto_type *type = tfm->__crt_alg->cra_type;
+
+       if (type) {
+               if (type->exit)
+                       type->exit(tfm);
+               return;
+       }
+
        switch (crypto_tfm_alg_type(tfm)) {
        case CRYPTO_ALG_TYPE_CIPHER:
                crypto_exit_cipher_ops(tfm);
@@ -278,26 +287,31 @@ static void crypto_exit_ops(struct crypto_tfm *tfm)
 
 static unsigned int crypto_ctxsize(struct crypto_alg *alg, int flags)
 {
+       const struct crypto_type *type = alg->cra_type;
        unsigned int len;
 
+       len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1);
+       if (type)
+               return len + type->ctxsize(alg);
+
        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, flags);
                break;
                
        case CRYPTO_ALG_TYPE_DIGEST:
-               len = crypto_digest_ctxsize(alg, flags);
+               len += crypto_digest_ctxsize(alg, flags);
                break;
                
        case CRYPTO_ALG_TYPE_COMPRESS:
-               len = crypto_compress_ctxsize(alg, flags);
+               len += crypto_compress_ctxsize(alg, flags);
                break;
        }
 
-       return len + (alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1));
+       return len;
 }
 
 void crypto_shoot_alg(struct crypto_alg *alg)
@@ -317,7 +331,7 @@ struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 flags)
        tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, flags);
        tfm = kzalloc(tfm_size, GFP_KERNEL);
        if (tfm == NULL)
-               goto out;
+               goto out_err;
 
        tfm->__crt_alg = alg;
 
@@ -341,6 +355,7 @@ cra_init_failed:
        crypto_exit_ops(tfm);
 out_free_tfm:
        kfree(tfm);
+out_err:
        tfm = ERR_PTR(err);
 out:
        return tfm;
@@ -400,14 +415,14 @@ struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask)
                struct crypto_alg *alg;
 
                alg = crypto_alg_mod_lookup(alg_name, type, mask);
-               err = PTR_ERR(alg);
-               tfm = ERR_PTR(err);
-               if (IS_ERR(alg))
+               if (IS_ERR(alg)) {
+                       err = PTR_ERR(alg);
                        goto err;
+               }
 
                tfm = __crypto_alloc_tfm(alg, 0);
                if (!IS_ERR(tfm))
-                       break;
+                       return tfm;
 
                crypto_mod_put(alg);
                err = PTR_ERR(tfm);
@@ -419,9 +434,9 @@ err:
                        err = -EINTR;
                        break;
                }
-       };
+       }
 
-       return tfm;
+       return ERR_PTR(err);
 }
 EXPORT_SYMBOL_GPL(crypto_alloc_base);
  
@@ -451,11 +466,13 @@ void crypto_free_tfm(struct crypto_tfm *tfm)
        kfree(tfm);
 }
 
-int crypto_alg_available(const char *name, u32 flags)
+EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
+EXPORT_SYMBOL_GPL(crypto_free_tfm);
+
+int crypto_has_alg(const char *name, u32 type, u32 mask)
 {
        int ret = 0;
-       struct crypto_alg *alg = crypto_alg_mod_lookup(name, 0,
-                                                      CRYPTO_ALG_ASYNC);
+       struct crypto_alg *alg = crypto_alg_mod_lookup(name, type, mask);
        
        if (!IS_ERR(alg)) {
                crypto_mod_put(alg);
@@ -464,7 +481,4 @@ int crypto_alg_available(const char *name, u32 flags)
        
        return ret;
 }
-
-EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
-EXPORT_SYMBOL_GPL(crypto_free_tfm);
-EXPORT_SYMBOL_GPL(crypto_alg_available);
+EXPORT_SYMBOL_GPL(crypto_has_alg);