Merge branch 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6

Pull crypto update from Herbert Xu:
 "API:
   - Try to catch hash output overrun in testmgr
   - Introduce walksize attribute for batched walking
   - Make crypto_xor() and crypto_inc() alignment agnostic

  Algorithms:
   - Add time-invariant AES algorithm
   - Add standalone CBCMAC algorithm

  Drivers:
   - Add NEON acclerated chacha20 on ARM/ARM64
   - Expose AES-CTR as synchronous skcipher on ARM64
   - Add scalar AES implementation on ARM64
   - Improve scalar AES implementation on ARM
   - Improve NEON AES implementation on ARM/ARM64
   - Merge CRC32 and PMULL instruction based drivers on ARM64
   - Add NEON acclerated CBCMAC/CMAC/XCBC AES on ARM64
   - Add IPsec AUTHENC implementation in atmel
   - Add Support for Octeon-tx CPT Engine
   - Add Broadcom SPU driver
   - Add MediaTek driver"

* 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6: (142 commits)
  crypto: xts - Add ECB dependency
  crypto: cavium - switch to pci_alloc_irq_vectors
  crypto: cavium - switch to pci_alloc_irq_vectors
  crypto: cavium - remove dead MSI-X related define
  crypto: brcm - Avoid double free in ahash_finup()
  crypto: cavium - fix Kconfig dependencies
  crypto: cavium - cpt_bind_vq_to_grp could return an error code
  crypto: doc - fix typo
  hwrng: omap - update Kconfig help description
  crypto: ccm - drop unnecessary minimum 32-bit alignment
  crypto: ccm - honour alignmask of subordinate MAC cipher
  crypto: caam - fix state buffer DMA (un)mapping
  crypto: caam - abstract ahash request double buffering
  crypto: caam - fix error path for ctx_dma mapping failure
  crypto: caam - fix DMA API leaks for multiple setkey() calls
  crypto: caam - don't dma_map key for hash algorithms
  crypto: caam - use dma_map_sg() return code
  crypto: caam - replace sg_count() with sg_nents_for_len()
  crypto: caam - check sg_count() return value
  crypto: caam - fix HW S/G in ablkcipher_giv_edesc_alloc()
  ..

1 files changed, 14 insertions, 9 deletions

diff --git a/crypto/skcipher.c b/crypto/skcipher.c
index 0e1e6c35188e..014af741fc6a 100644
--- a/crypto/skcipher.c
+++ b/crypto/skcipher.c
@@ -19,6 +19,7 @@
 #include <crypto/scatterwalk.h>
 #include <linux/bug.h>
 #include <linux/cryptouser.h>
+#include <linux/compiler.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/rtnetlink.h>
@@ -185,12 +186,12 @@ void skcipher_walk_complete(struct skcipher_walk *walk, int err)
                 data = p->data;
                 if (!data) {
                         data = PTR_ALIGN(&p->buffer[0], walk->alignmask + 1);
-                        data = skcipher_get_spot(data, walk->chunksize);
+                        data = skcipher_get_spot(data, walk->stride);
                 }
 
                 scatterwalk_copychunks(data, &p->dst, p->len, 1);
 
-                if (offset_in_page(p->data) + p->len + walk->chunksize >
+                if (offset_in_page(p->data) + p->len + walk->stride >
                     PAGE_SIZE)
                         free_page((unsigned long)p->data);
 
@@ -299,7 +300,7 @@ static int skcipher_next_copy(struct skcipher_walk *walk)
         p->len = walk->nbytes;
         skcipher_queue_write(walk, p);
 
-        if (offset_in_page(walk->page) + walk->nbytes + walk->chunksize >
+        if (offset_in_page(walk->page) + walk->nbytes + walk->stride >
             PAGE_SIZE)
                 walk->page = NULL;
         else
@@ -344,7 +345,7 @@ static int skcipher_walk_next(struct skcipher_walk *walk)
                          SKCIPHER_WALK_DIFF);
 
         n = walk->total;
-        bsize = min(walk->chunksize, max(n, walk->blocksize));
+        bsize = min(walk->stride, max(n, walk->blocksize));
         n = scatterwalk_clamp(&walk->in, n);
         n = scatterwalk_clamp(&walk->out, n);
 
@@ -393,7 +394,7 @@ static int skcipher_copy_iv(struct skcipher_walk *walk)
         unsigned a = crypto_tfm_ctx_alignment() - 1;
         unsigned alignmask = walk->alignmask;
         unsigned ivsize = walk->ivsize;
-        unsigned bs = walk->chunksize;
+        unsigned bs = walk->stride;
         unsigned aligned_bs;
         unsigned size;
         u8 *iv;
@@ -463,7 +464,7 @@ static int skcipher_walk_skcipher(struct skcipher_walk *walk,
                        SKCIPHER_WALK_SLEEP : 0;
 
         walk->blocksize = crypto_skcipher_blocksize(tfm);
-        walk->chunksize = crypto_skcipher_chunksize(tfm);
+        walk->stride = crypto_skcipher_walksize(tfm);
         walk->ivsize = crypto_skcipher_ivsize(tfm);
         walk->alignmask = crypto_skcipher_alignmask(tfm);
 
@@ -525,7 +526,7 @@ static int skcipher_walk_aead_common(struct skcipher_walk *walk,
                 walk->flags &= ~SKCIPHER_WALK_SLEEP;
 
         walk->blocksize = crypto_aead_blocksize(tfm);
-        walk->chunksize = crypto_aead_chunksize(tfm);
+        walk->stride = crypto_aead_chunksize(tfm);
         walk->ivsize = crypto_aead_ivsize(tfm);
         walk->alignmask = crypto_aead_alignmask(tfm);
 
@@ -807,7 +808,7 @@ static void crypto_skcipher_free_instance(struct crypto_instance *inst)
 }
 
 static void crypto_skcipher_show(struct seq_file *m, struct crypto_alg *alg)
-        __attribute__ ((unused));
+        __maybe_unused;
 static void crypto_skcipher_show(struct seq_file *m, struct crypto_alg *alg)
 {
         struct skcipher_alg *skcipher = container_of(alg, struct skcipher_alg,
@@ -821,6 +822,7 @@ static void crypto_skcipher_show(struct seq_file *m, struct crypto_alg *alg)
         seq_printf(m, "max keysize  : %u\n", skcipher->max_keysize);
         seq_printf(m, "ivsize       : %u\n", skcipher->ivsize);
         seq_printf(m, "chunksize    : %u\n", skcipher->chunksize);
+        seq_printf(m, "walksize     : %u\n", skcipher->walksize);
 }
 
 #ifdef CONFIG_NET
@@ -893,11 +895,14 @@ static int skcipher_prepare_alg(struct skcipher_alg *alg)
 {
         struct crypto_alg *base = &alg->base;
 
-        if (alg->ivsize > PAGE_SIZE / 8 || alg->chunksize > PAGE_SIZE / 8)
+        if (alg->ivsize > PAGE_SIZE / 8 || alg->chunksize > PAGE_SIZE / 8 ||
+            alg->walksize > PAGE_SIZE / 8)
                 return -EINVAL;
 
         if (!alg->chunksize)
                 alg->chunksize = base->cra_blocksize;
+        if (!alg->walksize)
+                alg->walksize = alg->chunksize;
 
         base->cra_type = &crypto_skcipher_type2;
         base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;