18 files changed, 154 insertions, 110 deletions

diff --git a/crypto/af_alg.c b/crypto/af_alg.c
index 85cea9de324a..35d4dcea381f 100644
--- a/crypto/af_alg.c
+++ b/crypto/af_alg.c
@@ -664,7 +664,7 @@ void af_alg_free_areq_sgls(struct af_alg_async_req *areq)
         unsigned int i;
 
         list_for_each_entry_safe(rsgl, tmp, &areq->rsgl_list, list) {
-                ctx->rcvused -= rsgl->sg_num_bytes;
+                atomic_sub(rsgl->sg_num_bytes, &ctx->rcvused);
                 af_alg_free_sg(&rsgl->sgl);
                 list_del(&rsgl->list);
                 if (rsgl != &areq->first_rsgl)
@@ -672,14 +672,15 @@ void af_alg_free_areq_sgls(struct af_alg_async_req *areq)
         }
 
         tsgl = areq->tsgl;
-        for_each_sg(tsgl, sg, areq->tsgl_entries, i) {
-                if (!sg_page(sg))
-                        continue;
-                put_page(sg_page(sg));
-        }
+        if (tsgl) {
+                for_each_sg(tsgl, sg, areq->tsgl_entries, i) {
+                        if (!sg_page(sg))
+                                continue;
+                        put_page(sg_page(sg));
+                }
 
-        if (areq->tsgl && areq->tsgl_entries)
                 sock_kfree_s(sk, tsgl, areq->tsgl_entries * sizeof(*tsgl));
+        }
 }
 EXPORT_SYMBOL_GPL(af_alg_free_areq_sgls);
 
@@ -1021,6 +1022,18 @@ unlock:
 EXPORT_SYMBOL_GPL(af_alg_sendpage);
 
 /**
+ * af_alg_free_resources - release resources required for crypto request
+ */
+void af_alg_free_resources(struct af_alg_async_req *areq)
+{
+        struct sock *sk = areq->sk;
+
+        af_alg_free_areq_sgls(areq);
+        sock_kfree_s(sk, areq, areq->areqlen);
+}
+EXPORT_SYMBOL_GPL(af_alg_free_resources);
+
+/**
  * af_alg_async_cb - AIO callback handler
  *
  * This handler cleans up the struct af_alg_async_req upon completion of the
@@ -1036,18 +1049,13 @@ void af_alg_async_cb(struct crypto_async_request *_req, int err)
         struct kiocb *iocb = areq->iocb;
         unsigned int resultlen;
 
-        lock_sock(sk);
-
         /* Buffer size written by crypto operation. */
         resultlen = areq->outlen;
 
-        af_alg_free_areq_sgls(areq);
-        sock_kfree_s(sk, areq, areq->areqlen);
-        __sock_put(sk);
+        af_alg_free_resources(areq);
+        sock_put(sk);
 
         iocb->ki_complete(iocb, err ? err : resultlen, 0);
-
-        release_sock(sk);
 }
 EXPORT_SYMBOL_GPL(af_alg_async_cb);
 
@@ -1130,12 +1138,6 @@ int af_alg_get_rsgl(struct sock *sk, struct msghdr *msg, int flags,
                 if (!af_alg_readable(sk))
                         break;
 
-                if (!ctx->used) {
-                        err = af_alg_wait_for_data(sk, flags);
-                        if (err)
-                                return err;
-                }
-
                 seglen = min_t(size_t, (maxsize - len),
                                msg_data_left(msg));
 
@@ -1161,7 +1163,7 @@ int af_alg_get_rsgl(struct sock *sk, struct msghdr *msg, int flags,
 
                 areq->last_rsgl = rsgl;
                 len += err;
-                ctx->rcvused += err;
+                atomic_add(err, &ctx->rcvused);
                 rsgl->sg_num_bytes = err;
                 iov_iter_advance(&msg->msg_iter, err);
         }
diff --git a/crypto/algapi.c b/crypto/algapi.c
index 60d7366ed343..9a636f961572 100644
--- a/crypto/algapi.c
+++ b/crypto/algapi.c
@@ -167,6 +167,18 @@ void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
 
                         spawn->alg = NULL;
                         spawns = &inst->alg.cra_users;
+
+                        /*
+                         * We may encounter an unregistered instance here, since
+                         * an instance's spawns are set up prior to the instance
+                         * being registered.  An unregistered instance will have
+                         * NULL ->cra_users.next, since ->cra_users isn't
+                         * properly initialized until registration.  But an
+                         * unregistered instance cannot have any users, so treat
+                         * it the same as ->cra_users being empty.
+                         */
+                        if (spawns->next == NULL)
+                                break;
                 }
         } while ((spawns = crypto_more_spawns(alg, &stack, &top,
                                               &secondary_spawns)));
diff --git a/crypto/algif_aead.c b/crypto/algif_aead.c
index aacae0837aff..e9885a35ef6e 100644
--- a/crypto/algif_aead.c
+++ b/crypto/algif_aead.c
@@ -101,16 +101,22 @@ static int _aead_recvmsg(struct socket *sock, struct msghdr *msg,
         struct aead_tfm *aeadc = pask->private;
         struct crypto_aead *tfm = aeadc->aead;
         struct crypto_skcipher *null_tfm = aeadc->null_tfm;
-        unsigned int as = crypto_aead_authsize(tfm);
+        unsigned int i, as = crypto_aead_authsize(tfm);
         struct af_alg_async_req *areq;
-        struct af_alg_tsgl *tsgl;
-        struct scatterlist *src;
+        struct af_alg_tsgl *tsgl, *tmp;
+        struct scatterlist *rsgl_src, *tsgl_src = NULL;
         int err = 0;
         size_t used = 0;                /* [in]  TX bufs to be en/decrypted */
         size_t outlen = 0;              /* [out] RX bufs produced by kernel */
         size_t usedpages = 0;           /* [in]  RX bufs to be used from user */
         size_t processed = 0;           /* [in]  TX bufs to be consumed */
 
+        if (!ctx->used) {
+                err = af_alg_wait_for_data(sk, flags);
+                if (err)
+                        return err;
+        }
+
         /*
          * Data length provided by caller via sendmsg/sendpage that has not
          * yet been processed.
@@ -178,7 +184,22 @@ static int _aead_recvmsg(struct socket *sock, struct msghdr *msg,
         }
 
         processed = used + ctx->aead_assoclen;
-        tsgl = list_first_entry(&ctx->tsgl_list, struct af_alg_tsgl, list);
+        list_for_each_entry_safe(tsgl, tmp, &ctx->tsgl_list, list) {
+                for (i = 0; i < tsgl->cur; i++) {
+                        struct scatterlist *process_sg = tsgl->sg + i;
+
+                        if (!(process_sg->length) || !sg_page(process_sg))
+                                continue;
+                        tsgl_src = process_sg;
+                        break;
+                }
+                if (tsgl_src)
+                        break;
+        }
+        if (processed && !tsgl_src) {
+                err = -EFAULT;
+                goto free;
+        }
 
         /*
          * Copy of AAD from source to destination
@@ -194,7 +215,7 @@ static int _aead_recvmsg(struct socket *sock, struct msghdr *msg,
          */
 
         /* Use the RX SGL as source (and destination) for crypto op. */
-        src = areq->first_rsgl.sgl.sg;
+        rsgl_src = areq->first_rsgl.sgl.sg;
 
         if (ctx->enc) {
                 /*
@@ -207,7 +228,7 @@ static int _aead_recvmsg(struct socket *sock, struct msghdr *msg,
                  *          v      v
                  * RX SGL: AAD || PT || Tag
                  */
-                err = crypto_aead_copy_sgl(null_tfm, tsgl->sg,
+                err = crypto_aead_copy_sgl(null_tfm, tsgl_src,
                                            areq->first_rsgl.sgl.sg, processed);
                 if (err)
                         goto free;
@@ -225,7 +246,7 @@ static int _aead_recvmsg(struct socket *sock, struct msghdr *msg,
                  */
 
                  /* Copy AAD || CT to RX SGL buffer for in-place operation. */
-                err = crypto_aead_copy_sgl(null_tfm, tsgl->sg,
+                err = crypto_aead_copy_sgl(null_tfm, tsgl_src,
                                            areq->first_rsgl.sgl.sg, outlen);
                 if (err)
                         goto free;
@@ -257,23 +278,34 @@ static int _aead_recvmsg(struct socket *sock, struct msghdr *msg,
                                  areq->tsgl);
                 } else
                         /* no RX SGL present (e.g. authentication only) */
-                        src = areq->tsgl;
+                        rsgl_src = areq->tsgl;
         }
 
         /* Initialize the crypto operation */
-        aead_request_set_crypt(&areq->cra_u.aead_req, src,
+        aead_request_set_crypt(&areq->cra_u.aead_req, rsgl_src,
                                areq->first_rsgl.sgl.sg, used, ctx->iv);
         aead_request_set_ad(&areq->cra_u.aead_req, ctx->aead_assoclen);
         aead_request_set_tfm(&areq->cra_u.aead_req, tfm);
 
         if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
                 /* AIO operation */
+                sock_hold(sk);
                 areq->iocb = msg->msg_iocb;
+
+                /* Remember output size that will be generated. */
+                areq->outlen = outlen;
+
                 aead_request_set_callback(&areq->cra_u.aead_req,
                                           CRYPTO_TFM_REQ_MAY_BACKLOG,
                                           af_alg_async_cb, areq);
                 err = ctx->enc ? crypto_aead_encrypt(&areq->cra_u.aead_req) :
                                  crypto_aead_decrypt(&areq->cra_u.aead_req);
+
+                /* AIO operation in progress */
+                if (err == -EINPROGRESS || err == -EBUSY)
+                        return -EIOCBQUEUED;
+
+                sock_put(sk);
         } else {
                 /* Synchronous operation */
                 aead_request_set_callback(&areq->cra_u.aead_req,
@@ -285,19 +317,9 @@ static int _aead_recvmsg(struct socket *sock, struct msghdr *msg,
                                 &ctx->wait);
         }
 
-        /* AIO operation in progress */
-        if (err == -EINPROGRESS) {
-                sock_hold(sk);
-
-                /* Remember output size that will be generated. */
-                areq->outlen = outlen;
-
-                return -EIOCBQUEUED;
-        }
 
 free:
-        af_alg_free_areq_sgls(areq);
-        sock_kfree_s(sk, areq, areq->areqlen);
+        af_alg_free_resources(areq);
 
         return err ? err : outlen;
 }
@@ -487,6 +509,7 @@ static void aead_release(void *private)
         struct aead_tfm *tfm = private;
 
         crypto_free_aead(tfm->aead);
+        crypto_put_default_null_skcipher2();
         kfree(tfm);
 }
 
@@ -519,7 +542,6 @@ static void aead_sock_destruct(struct sock *sk)
         unsigned int ivlen = crypto_aead_ivsize(tfm);
 
         af_alg_pull_tsgl(sk, ctx->used, NULL, 0);
-        crypto_put_default_null_skcipher2();
         sock_kzfree_s(sk, ctx->iv, ivlen);
         sock_kfree_s(sk, ctx, ctx->len);
         af_alg_release_parent(sk);
@@ -549,7 +571,7 @@ static int aead_accept_parent_nokey(void *private, struct sock *sk)
         INIT_LIST_HEAD(&ctx->tsgl_list);
         ctx->len = len;
         ctx->used = 0;
-        ctx->rcvused = 0;
+        atomic_set(&ctx->rcvused, 0);
         ctx->more = 0;
         ctx->merge = 0;
         ctx->enc = 0;
diff --git a/crypto/algif_skcipher.c b/crypto/algif_skcipher.c
index 9954b078f0b9..c5c47b680152 100644
--- a/crypto/algif_skcipher.c
+++ b/crypto/algif_skcipher.c
@@ -72,6 +72,12 @@ static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
         int err = 0;
         size_t len = 0;
 
+        if (!ctx->used) {
+                err = af_alg_wait_for_data(sk, flags);
+                if (err)
+                        return err;
+        }
+
         /* Allocate cipher request for current operation. */
         areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) +
                                      crypto_skcipher_reqsize(tfm));
@@ -117,13 +123,24 @@ static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
 
         if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
                 /* AIO operation */
+                sock_hold(sk);
                 areq->iocb = msg->msg_iocb;
+
+                /* Remember output size that will be generated. */
+                areq->outlen = len;
+
                 skcipher_request_set_callback(&areq->cra_u.skcipher_req,
                                               CRYPTO_TFM_REQ_MAY_SLEEP,
                                               af_alg_async_cb, areq);
                 err = ctx->enc ?
                         crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
                         crypto_skcipher_decrypt(&areq->cra_u.skcipher_req);
+
+                /* AIO operation in progress */
+                if (err == -EINPROGRESS || err == -EBUSY)
+                        return -EIOCBQUEUED;
+
+                sock_put(sk);
         } else {
                 /* Synchronous operation */
                 skcipher_request_set_callback(&areq->cra_u.skcipher_req,
@@ -136,19 +153,9 @@ static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
                                                  &ctx->wait);
         }
 
-        /* AIO operation in progress */
-        if (err == -EINPROGRESS) {
-                sock_hold(sk);
-
-                /* Remember output size that will be generated. */
-                areq->outlen = len;
-
-                return -EIOCBQUEUED;
-        }
 
 free:
-        af_alg_free_areq_sgls(areq);
-        sock_kfree_s(sk, areq, areq->areqlen);
+        af_alg_free_resources(areq);
 
         return err ? err : len;
 }
@@ -383,7 +390,7 @@ static int skcipher_accept_parent_nokey(void *private, struct sock *sk)
         INIT_LIST_HEAD(&ctx->tsgl_list);
         ctx->len = len;
         ctx->used = 0;
-        ctx->rcvused = 0;
+        atomic_set(&ctx->rcvused, 0);
         ctx->more = 0;
         ctx->merge = 0;
         ctx->enc = 0;
diff --git a/crypto/asymmetric_keys/pkcs7_parser.c b/crypto/asymmetric_keys/pkcs7_parser.c
index c1ca1e86f5c4..a6dcaa659aa8 100644
--- a/crypto/asymmetric_keys/pkcs7_parser.c
+++ b/crypto/asymmetric_keys/pkcs7_parser.c
@@ -148,8 +148,10 @@ struct pkcs7_message *pkcs7_parse_message(const void *data, size_t datalen)
         }
 
         ret = pkcs7_check_authattrs(ctx->msg);
-        if (ret < 0)
+        if (ret < 0) {
+                msg = ERR_PTR(ret);
                 goto out;
+        }
 
         msg = ctx->msg;
         ctx->msg = NULL;
diff --git a/crypto/asymmetric_keys/pkcs7_trust.c b/crypto/asymmetric_keys/pkcs7_trust.c
index f6a009d88a33..1f4e25f10049 100644
--- a/crypto/asymmetric_keys/pkcs7_trust.c
+++ b/crypto/asymmetric_keys/pkcs7_trust.c
@@ -69,7 +69,7 @@ static int pkcs7_validate_trust_one(struct pkcs7_message *pkcs7,
                  /* Self-signed certificates form roots of their own, and if we
                   * don't know them, then we can't accept them.
                   */
-                if (x509->next == x509) {
+                if (x509->signer == x509) {
                         kleave(" = -ENOKEY [unknown self-signed]");
                         return -ENOKEY;
                 }
diff --git a/crypto/asymmetric_keys/pkcs7_verify.c b/crypto/asymmetric_keys/pkcs7_verify.c
index 2d93d9eccb4d..39e6de0c2761 100644
--- a/crypto/asymmetric_keys/pkcs7_verify.c
+++ b/crypto/asymmetric_keys/pkcs7_verify.c
@@ -59,11 +59,8 @@ static int pkcs7_digest(struct pkcs7_message *pkcs7,
         desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;
 
         /* Digest the message [RFC2315 9.3] */
-        ret = crypto_shash_init(desc);
-        if (ret < 0)
-                goto error;
-        ret = crypto_shash_finup(desc, pkcs7->data, pkcs7->data_len,
-                                 sig->digest);
+        ret = crypto_shash_digest(desc, pkcs7->data, pkcs7->data_len,
+                                  sig->digest);
         if (ret < 0)
                 goto error;
         pr_devel("MsgDigest = [%*ph]\n", 8, sig->digest);
@@ -150,7 +147,7 @@ static int pkcs7_find_key(struct pkcs7_message *pkcs7,
                 pr_devel("Sig %u: Found cert serial match X.509[%u]\n",
                          sinfo->index, certix);
 
-                if (x509->pub->pkey_algo != sinfo->sig->pkey_algo) {
+                if (strcmp(x509->pub->pkey_algo, sinfo->sig->pkey_algo) != 0) {
                         pr_warn("Sig %u: X.509 algo and PKCS#7 sig algo don't match\n",
                                 sinfo->index);
                         continue;
diff --git a/crypto/asymmetric_keys/public_key.c b/crypto/asymmetric_keys/public_key.c
index bc3035ef27a2..de996586762a 100644
--- a/crypto/asymmetric_keys/public_key.c
+++ b/crypto/asymmetric_keys/public_key.c
@@ -73,7 +73,7 @@ int public_key_verify_signature(const struct public_key *pkey,
         char alg_name_buf[CRYPTO_MAX_ALG_NAME];
         void *output;
         unsigned int outlen;
-        int ret = -ENOMEM;
+        int ret;
 
         pr_devel("==>%s()\n", __func__);
 
@@ -99,6 +99,7 @@ int public_key_verify_signature(const struct public_key *pkey,
         if (IS_ERR(tfm))
                 return PTR_ERR(tfm);
 
+        ret = -ENOMEM;
         req = akcipher_request_alloc(tfm, GFP_KERNEL);
         if (!req)
                 goto error_free_tfm;
@@ -127,7 +128,7 @@ int public_key_verify_signature(const struct public_key *pkey,
          * signature and returns that to us.
          */
         ret = crypto_wait_req(crypto_akcipher_verify(req), &cwait);
-        if (ret < 0)
+        if (ret)
                 goto out_free_output;
 
         /* Do the actual verification step. */
@@ -142,6 +143,8 @@ error_free_req:
 error_free_tfm:
         crypto_free_akcipher(tfm);
         pr_devel("<==%s() = %d\n", __func__, ret);
+        if (WARN_ON_ONCE(ret > 0))
+                ret = -EINVAL;
         return ret;
 }
 EXPORT_SYMBOL_GPL(public_key_verify_signature);
diff --git a/crypto/asymmetric_keys/x509_cert_parser.c b/crypto/asymmetric_keys/x509_cert_parser.c
index dd03fead1ca3..ce2df8c9c583 100644
--- a/crypto/asymmetric_keys/x509_cert_parser.c
+++ b/crypto/asymmetric_keys/x509_cert_parser.c
@@ -409,6 +409,8 @@ int x509_extract_key_data(void *context, size_t hdrlen,
         ctx->cert->pub->pkey_algo = "rsa";
 
         /* Discard the BIT STRING metadata */
+        if (vlen < 1 || *(const u8 *)value != 0)
+                return -EBADMSG;
         ctx->key = value + 1;
         ctx->key_size = vlen - 1;
         return 0;
diff --git a/crypto/asymmetric_keys/x509_public_key.c b/crypto/asymmetric_keys/x509_public_key.c
index c9013582c026..9338b4558cdc 100644
--- a/crypto/asymmetric_keys/x509_public_key.c
+++ b/crypto/asymmetric_keys/x509_public_key.c
@@ -79,11 +79,7 @@ int x509_get_sig_params(struct x509_certificate *cert)
         desc->tfm = tfm;
         desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;
 
-        ret = crypto_shash_init(desc);
-        if (ret < 0)
-                goto error_2;
-        might_sleep();
-        ret = crypto_shash_finup(desc, cert->tbs, cert->tbs_size, sig->digest);
+        ret = crypto_shash_digest(desc, cert->tbs, cert->tbs_size, sig->digest);
         if (ret < 0)
                 goto error_2;
 
@@ -135,7 +131,7 @@ int x509_check_for_self_signed(struct x509_certificate *cert)
         }
 
         ret = -EKEYREJECTED;
-        if (cert->pub->pkey_algo != cert->sig->pkey_algo)
+        if (strcmp(cert->pub->pkey_algo, cert->sig->pkey_algo) != 0)
                 goto out;
 
         ret = public_key_verify_signature(cert->pub, cert->sig);
diff --git a/crypto/chacha20poly1305.c b/crypto/chacha20poly1305.c
index db1bc3147bc4..600afa99941f 100644
--- a/crypto/chacha20poly1305.c
+++ b/crypto/chacha20poly1305.c
@@ -610,6 +610,11 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,
                                                     algt->mask));
         if (IS_ERR(poly))
                 return PTR_ERR(poly);
+        poly_hash = __crypto_hash_alg_common(poly);
+
+        err = -EINVAL;
+        if (poly_hash->digestsize != POLY1305_DIGEST_SIZE)
+                goto out_put_poly;
 
         err = -ENOMEM;
         inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
@@ -618,7 +623,6 @@ static int chachapoly_create(struct crypto_template *tmpl, struct rtattr **tb,
 
         ctx = aead_instance_ctx(inst);
         ctx->saltlen = CHACHAPOLY_IV_SIZE - ivsize;
-        poly_hash = __crypto_hash_alg_common(poly);
         err = crypto_init_ahash_spawn(&ctx->poly, poly_hash,
                                       aead_crypto_instance(inst));
         if (err)
diff --git a/crypto/hmac.c b/crypto/hmac.c
index 92871dc2a63e..e74730224f0a 100644
--- a/crypto/hmac.c
+++ b/crypto/hmac.c
@@ -195,11 +195,15 @@ static int hmac_create(struct crypto_template *tmpl, struct rtattr **tb)
         salg = shash_attr_alg(tb[1], 0, 0);
         if (IS_ERR(salg))
                 return PTR_ERR(salg);
+        alg = &salg->base;
 
+        /* The underlying hash algorithm must be unkeyed */
         err = -EINVAL;
+        if (crypto_shash_alg_has_setkey(salg))
+                goto out_put_alg;
+
         ds = salg->digestsize;
         ss = salg->statesize;
-        alg = &salg->base;
         if (ds > alg->cra_blocksize ||
             ss < alg->cra_blocksize)
                 goto out_put_alg;
diff --git a/crypto/mcryptd.c b/crypto/mcryptd.c
index 4e6472658852..eca04d3729b3 100644
--- a/crypto/mcryptd.c
+++ b/crypto/mcryptd.c
@@ -81,6 +81,7 @@ static int mcryptd_init_queue(struct mcryptd_queue *queue,
                 pr_debug("cpu_queue #%d %p\n", cpu, queue->cpu_queue);
                 crypto_init_queue(&cpu_queue->queue, max_cpu_qlen);
                 INIT_WORK(&cpu_queue->work, mcryptd_queue_worker);
+                spin_lock_init(&cpu_queue->q_lock);
         }
         return 0;
 }
@@ -104,15 +105,16 @@ static int mcryptd_enqueue_request(struct mcryptd_queue *queue,
         int cpu, err;
         struct mcryptd_cpu_queue *cpu_queue;
 
-        cpu = get_cpu();
-        cpu_queue = this_cpu_ptr(queue->cpu_queue);
-        rctx->tag.cpu = cpu;
+        cpu_queue = raw_cpu_ptr(queue->cpu_queue);
+        spin_lock(&cpu_queue->q_lock);
+        cpu = smp_processor_id();
+        rctx->tag.cpu = smp_processor_id();
 
         err = crypto_enqueue_request(&cpu_queue->queue, request);
         pr_debug("enqueue request: cpu %d cpu_queue %p request %p\n",
                  cpu, cpu_queue, request);
+        spin_unlock(&cpu_queue->q_lock);
         queue_work_on(cpu, kcrypto_wq, &cpu_queue->work);
-        put_cpu();
 
         return err;
 }
@@ -161,16 +163,11 @@ static void mcryptd_queue_worker(struct work_struct *work)
         cpu_queue = container_of(work, struct mcryptd_cpu_queue, work);
         i = 0;
         while (i < MCRYPTD_BATCH || single_task_running()) {
-                /*
-                 * preempt_disable/enable is used to prevent
-                 * being preempted by mcryptd_enqueue_request()
-                 */
-                local_bh_disable();
-                preempt_disable();
+
+                spin_lock_bh(&cpu_queue->q_lock);
                 backlog = crypto_get_backlog(&cpu_queue->queue);
                 req = crypto_dequeue_request(&cpu_queue->queue);
-                preempt_enable();
-                local_bh_enable();
+                spin_unlock_bh(&cpu_queue->q_lock);
 
                 if (!req) {
                         mcryptd_opportunistic_flush();
@@ -185,7 +182,7 @@ static void mcryptd_queue_worker(struct work_struct *work)
                 ++i;
         }
         if (cpu_queue->queue.qlen)
-                queue_work(kcrypto_wq, &cpu_queue->work);
+                queue_work_on(smp_processor_id(), kcrypto_wq, &cpu_queue->work);
 }
 
 void mcryptd_flusher(struct work_struct *__work)
diff --git a/crypto/pcrypt.c b/crypto/pcrypt.c
index ee9cfb99fe25..f8ec3d4ba4a8 100644
--- a/crypto/pcrypt.c
+++ b/crypto/pcrypt.c
@@ -254,6 +254,14 @@ static void pcrypt_aead_exit_tfm(struct crypto_aead *tfm)
         crypto_free_aead(ctx->child);
 }
 
+static void pcrypt_free(struct aead_instance *inst)
+{
+        struct pcrypt_instance_ctx *ctx = aead_instance_ctx(inst);
+
+        crypto_drop_aead(&ctx->spawn);
+        kfree(inst);
+}
+
 static int pcrypt_init_instance(struct crypto_instance *inst,
                                 struct crypto_alg *alg)
 {
@@ -319,6 +327,8 @@ static int pcrypt_create_aead(struct crypto_template *tmpl, struct rtattr **tb,
         inst->alg.encrypt = pcrypt_aead_encrypt;
         inst->alg.decrypt = pcrypt_aead_decrypt;
 
+        inst->free = pcrypt_free;
+
         err = aead_register_instance(tmpl, inst);
         if (err)
                 goto out_drop_aead;
@@ -349,14 +359,6 @@ static int pcrypt_create(struct crypto_template *tmpl, struct rtattr **tb)
         return -EINVAL;
 }
 
-static void pcrypt_free(struct crypto_instance *inst)
-{
-        struct pcrypt_instance_ctx *ctx = crypto_instance_ctx(inst);
-
-        crypto_drop_aead(&ctx->spawn);
-        kfree(inst);
-}
-
 static int pcrypt_cpumask_change_notify(struct notifier_block *self,
                                         unsigned long val, void *data)
 {
@@ -469,7 +471,6 @@ static void pcrypt_fini_padata(struct padata_pcrypt *pcrypt)
 static struct crypto_template pcrypt_tmpl = {
         .name = "pcrypt",
         .create = pcrypt_create,
-        .free = pcrypt_free,
         .module = THIS_MODULE,
 };
 
diff --git a/crypto/rsa_helper.c b/crypto/rsa_helper.c
index 0b66dc824606..cad395d70d78 100644
--- a/crypto/rsa_helper.c
+++ b/crypto/rsa_helper.c
@@ -30,7 +30,7 @@ int rsa_get_n(void *context, size_t hdrlen, unsigned char tag,
                 return -EINVAL;
 
         if (fips_enabled) {
-                while (!*ptr && n_sz) {
+                while (n_sz && !*ptr) {
                         ptr++;
                         n_sz--;
                 }
diff --git a/crypto/salsa20_generic.c b/crypto/salsa20_generic.c
index f550b5d94630..d7da0eea5622 100644
--- a/crypto/salsa20_generic.c
+++ b/crypto/salsa20_generic.c
@@ -188,13 +188,6 @@ static int encrypt(struct blkcipher_desc *desc,
 
         salsa20_ivsetup(ctx, walk.iv);
 
-        if (likely(walk.nbytes == nbytes))
-        {
-                salsa20_encrypt_bytes(ctx, walk.dst.virt.addr,
-                                      walk.src.virt.addr, nbytes);
-                return blkcipher_walk_done(desc, &walk, 0);
-        }
-
         while (walk.nbytes >= 64) {
                 salsa20_encrypt_bytes(ctx, walk.dst.virt.addr,
                                       walk.src.virt.addr,
diff --git a/crypto/shash.c b/crypto/shash.c
index 325a14da5827..e849d3ee2e27 100644
--- a/crypto/shash.c
+++ b/crypto/shash.c
@@ -25,11 +25,12 @@
 
 static const struct crypto_type crypto_shash_type;
 
-static int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
-                           unsigned int keylen)
+int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
+                    unsigned int keylen)
 {
         return -ENOSYS;
 }
+EXPORT_SYMBOL_GPL(shash_no_setkey);
 
 static int shash_setkey_unaligned(struct crypto_shash *tfm, const u8 *key,
                                   unsigned int keylen)
diff --git a/crypto/skcipher.c b/crypto/skcipher.c
index d5692e35fab1..11af5fd6a443 100644
--- a/crypto/skcipher.c
+++ b/crypto/skcipher.c
@@ -449,6 +449,8 @@ static int skcipher_walk_skcipher(struct skcipher_walk *walk,
 
         walk->total = req->cryptlen;
         walk->nbytes = 0;
+        walk->iv = req->iv;
+        walk->oiv = req->iv;
 
         if (unlikely(!walk->total))
                 return 0;
@@ -456,9 +458,6 @@ static int skcipher_walk_skcipher(struct skcipher_walk *walk,
         scatterwalk_start(&walk->in, req->src);
         scatterwalk_start(&walk->out, req->dst);
 
-        walk->iv = req->iv;
-        walk->oiv = req->iv;
-
         walk->flags &= ~SKCIPHER_WALK_SLEEP;
         walk->flags |= req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ?
                        SKCIPHER_WALK_SLEEP : 0;
@@ -510,6 +509,8 @@ static int skcipher_walk_aead_common(struct skcipher_walk *walk,
         int err;
 
         walk->nbytes = 0;
+        walk->iv = req->iv;
+        walk->oiv = req->iv;
 
         if (unlikely(!walk->total))
                 return 0;
@@ -522,8 +523,8 @@ static int skcipher_walk_aead_common(struct skcipher_walk *walk,
         scatterwalk_copychunks(NULL, &walk->in, req->assoclen, 2);
         scatterwalk_copychunks(NULL, &walk->out, req->assoclen, 2);
 
-        walk->iv = req->iv;
-        walk->oiv = req->iv;
+        scatterwalk_done(&walk->in, 0, walk->total);
+        scatterwalk_done(&walk->out, 0, walk->total);
 
         if (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP)
                 walk->flags |= SKCIPHER_WALK_SLEEP;