Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

4 files changed, 87 insertions, 9 deletions

diff --git a/crypto/ablkcipher.c b/crypto/ablkcipher.c
index c22374bf9f1e..533de9550a82 100644
--- a/crypto/ablkcipher.c
+++ b/crypto/ablkcipher.c
@@ -613,8 +613,7 @@ out:
         return err;
 }
 
-static struct crypto_alg *crypto_lookup_skcipher(const char *name, u32 type,
-                                                 u32 mask)
+struct crypto_alg *crypto_lookup_skcipher(const char *name, u32 type, u32 mask)
 {
         struct crypto_alg *alg;
 
@@ -652,6 +651,7 @@ static struct crypto_alg *crypto_lookup_skcipher(const char *name, u32 type,
 
         return ERR_PTR(crypto_givcipher_default(alg, type, mask));
 }
+EXPORT_SYMBOL_GPL(crypto_lookup_skcipher);
 
 int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, const char *name,
                          u32 type, u32 mask)
diff --git a/crypto/aead.c b/crypto/aead.c
index c772b9c79ee7..0b8121ebec07 100644
--- a/crypto/aead.c
+++ b/crypto/aead.c
@@ -470,8 +470,7 @@ out:
         return err;
 }
 
-static struct crypto_alg *crypto_lookup_aead(const char *name, u32 type,
-                                             u32 mask)
+struct crypto_alg *crypto_lookup_aead(const char *name, u32 type, u32 mask)
 {
         struct crypto_alg *alg;
 
@@ -503,6 +502,7 @@ static struct crypto_alg *crypto_lookup_aead(const char *name, u32 type,
 
         return ERR_PTR(crypto_nivaead_default(alg, type, mask));
 }
+EXPORT_SYMBOL_GPL(crypto_lookup_aead);
 
 int crypto_grab_aead(struct crypto_aead_spawn *spawn, const char *name,
                      u32 type, u32 mask)
diff --git a/crypto/crypto_user.c b/crypto/crypto_user.c
index 84a5ac71ecb4..5a37eadb4e56 100644
--- a/crypto/crypto_user.c
+++ b/crypto/crypto_user.c
@@ -21,9 +21,13 @@
 #include <linux/module.h>
 #include <linux/crypto.h>
 #include <linux/cryptouser.h>
+#include <linux/sched.h>
 #include <net/netlink.h>
 #include <linux/security.h>
 #include <net/net_namespace.h>
+#include <crypto/internal/aead.h>
+#include <crypto/internal/skcipher.h>
+
 #include "internal.h"
 
 DEFINE_MUTEX(crypto_cfg_mutex);
@@ -301,6 +305,60 @@ static int crypto_del_alg(struct sk_buff *skb, struct nlmsghdr *nlh,
         return crypto_unregister_instance(alg);
 }
 
+static struct crypto_alg *crypto_user_skcipher_alg(const char *name, u32 type,
+                                                   u32 mask)
+{
+        int err;
+        struct crypto_alg *alg;
+
+        type = crypto_skcipher_type(type);
+        mask = crypto_skcipher_mask(mask);
+
+        for (;;) {
+                alg = crypto_lookup_skcipher(name,  type, mask);
+                if (!IS_ERR(alg))
+                        return alg;
+
+                err = PTR_ERR(alg);
+                if (err != -EAGAIN)
+                        break;
+                if (signal_pending(current)) {
+                        err = -EINTR;
+                        break;
+                }
+        }
+
+        return ERR_PTR(err);
+}
+
+static struct crypto_alg *crypto_user_aead_alg(const char *name, u32 type,
+                                               u32 mask)
+{
+        int err;
+        struct crypto_alg *alg;
+
+        type &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV);
+        type |= CRYPTO_ALG_TYPE_AEAD;
+        mask &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV);
+        mask |= CRYPTO_ALG_TYPE_MASK;
+
+        for (;;) {
+                alg = crypto_lookup_aead(name,  type, mask);
+                if (!IS_ERR(alg))
+                        return alg;
+
+                err = PTR_ERR(alg);
+                if (err != -EAGAIN)
+                        break;
+                if (signal_pending(current)) {
+                        err = -EINTR;
+                        break;
+                }
+        }
+
+        return ERR_PTR(err);
+}
+
 static int crypto_add_alg(struct sk_buff *skb, struct nlmsghdr *nlh,
                           struct nlattr **attrs)
 {
@@ -325,7 +383,19 @@ static int crypto_add_alg(struct sk_buff *skb, struct nlmsghdr *nlh,
         else
                 name = p->cru_name;
 
-        alg = crypto_alg_mod_lookup(name, p->cru_type, p->cru_mask);
+        switch (p->cru_type & p->cru_mask & CRYPTO_ALG_TYPE_MASK) {
+        case CRYPTO_ALG_TYPE_AEAD:
+                alg = crypto_user_aead_alg(name, p->cru_type, p->cru_mask);
+                break;
+        case CRYPTO_ALG_TYPE_GIVCIPHER:
+        case CRYPTO_ALG_TYPE_BLKCIPHER:
+        case CRYPTO_ALG_TYPE_ABLKCIPHER:
+                alg = crypto_user_skcipher_alg(name, p->cru_type, p->cru_mask);
+                break;
+        default:
+                alg = crypto_alg_mod_lookup(name, p->cru_type, p->cru_mask);
+        }
+
         if (IS_ERR(alg))
                 return PTR_ERR(alg);
 
@@ -387,12 +457,20 @@ static int crypto_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
 
         if ((type == (CRYPTO_MSG_GETALG - CRYPTO_MSG_BASE) &&
             (nlh->nlmsg_flags & NLM_F_DUMP))) {
+                struct crypto_alg *alg;
+                u16 dump_alloc = 0;
+
                 if (link->dump == NULL)
                         return -EINVAL;
+
+                list_for_each_entry(alg, &crypto_alg_list, cra_list)
+                        dump_alloc += CRYPTO_REPORT_MAXSIZE;
+
                 {
                         struct netlink_dump_control c = {
                                 .dump = link->dump,
                                 .done = link->done,
+                                .min_dump_alloc = dump_alloc,
                         };
                         return netlink_dump_start(crypto_nlsk, skb, nlh, &c);
                 }
diff --git a/crypto/pcrypt.c b/crypto/pcrypt.c
index 29a89dad68b6..b2c99dc1c5e2 100644
--- a/crypto/pcrypt.c
+++ b/crypto/pcrypt.c
@@ -280,11 +280,11 @@ static int pcrypt_aead_init_tfm(struct crypto_tfm *tfm)
 
         ictx->tfm_count++;
 
-        cpu_index = ictx->tfm_count % cpumask_weight(cpu_active_mask);
+        cpu_index = ictx->tfm_count % cpumask_weight(cpu_online_mask);
 
-        ctx->cb_cpu = cpumask_first(cpu_active_mask);
+        ctx->cb_cpu = cpumask_first(cpu_online_mask);
         for (cpu = 0; cpu < cpu_index; cpu++)
-                ctx->cb_cpu = cpumask_next(ctx->cb_cpu, cpu_active_mask);
+                ctx->cb_cpu = cpumask_next(ctx->cb_cpu, cpu_online_mask);
 
         cipher = crypto_spawn_aead(crypto_instance_ctx(inst));
 
@@ -472,7 +472,7 @@ static int pcrypt_init_padata(struct padata_pcrypt *pcrypt,
                 goto err_free_padata;
         }
 
-        cpumask_and(mask->mask, cpu_possible_mask, cpu_active_mask);
+        cpumask_and(mask->mask, cpu_possible_mask, cpu_online_mask);
         rcu_assign_pointer(pcrypt->cb_cpumask, mask);
 
         pcrypt->nblock.notifier_call = pcrypt_cpumask_change_notify;