Driver Core: fix bug in device_rename() for SYSFS_DEPRECATED=y

[linux-2.6-omap-h63xx.git] / crypto / blkcipher.c

diff --git a/crypto/blkcipher.c b/crypto/blkcipher.c
index d8f8ec320213a4fc4656ad9340b30ddc904328a0..f6c67f9d4e5c2f9085558991a6fc87893e269670 100644 (file)
--- a/crypto/blkcipher.c
+++ b/crypto/blkcipher.c
@@ -65,7 +65,7 @@ static inline void blkcipher_unmap_dst(struct blkcipher_walk *walk)
 static inline u8 *blkcipher_get_spot(u8 *start, unsigned int len)
 {
        u8 *end_page = (u8 *)(((unsigned long)(start + len - 1)) & PAGE_MASK);
-       return start > end_page ? start : end_page;
+       return max(start, end_page);
 }
 
 static inline unsigned int blkcipher_done_slow(struct crypto_blkcipher *tfm,
@@ -84,8 +84,6 @@ static inline unsigned int blkcipher_done_slow(struct crypto_blkcipher *tfm,
 static inline unsigned int blkcipher_done_fast(struct blkcipher_walk *walk,
                                               unsigned int n)
 {
-       n = walk->nbytes - n;
-
        if (walk->flags & BLKCIPHER_WALK_COPY) {
                blkcipher_map_dst(walk);
                memcpy(walk->dst.virt.addr, walk->page, n);
@@ -109,13 +107,15 @@ int blkcipher_walk_done(struct blkcipher_desc *desc,
        unsigned int nbytes = 0;
 
        if (likely(err >= 0)) {
-               unsigned int bsize = crypto_blkcipher_blocksize(tfm);
-               unsigned int n;
+               unsigned int n = walk->nbytes - err;
 
                if (likely(!(walk->flags & BLKCIPHER_WALK_SLOW)))
-                       n = blkcipher_done_fast(walk, err);
-               else
-                       n = blkcipher_done_slow(tfm, walk, bsize);
+                       n = blkcipher_done_fast(walk, n);
+               else if (WARN_ON(err)) {
+                       err = -EINVAL;
+                       goto err;
+               } else
+                       n = blkcipher_done_slow(tfm, walk, n);
 
                nbytes = walk->total - n;
                err = 0;
@@ -132,6 +132,7 @@ int blkcipher_walk_done(struct blkcipher_desc *desc,
                return blkcipher_walk_next(desc, walk);
        }
 
+err:
        if (walk->iv != desc->info)
                memcpy(desc->info, walk->iv, crypto_blkcipher_ivsize(tfm));
        if (walk->buffer != walk->page)
@@ -149,6 +150,7 @@ static inline int blkcipher_next_slow(struct blkcipher_desc *desc,
                                      unsigned int alignmask)
 {
        unsigned int n;
+       unsigned aligned_bsize = ALIGN(bsize, alignmask + 1);
 
        if (walk->buffer)
                goto ok;
@@ -157,7 +159,7 @@ static inline int blkcipher_next_slow(struct blkcipher_desc *desc,
        if (walk->buffer)
                goto ok;
 
-       n = bsize * 3 - (alignmask + 1) +
+       n = aligned_bsize * 3 - (alignmask + 1) +
            (alignmask & ~(crypto_tfm_ctx_alignment() - 1));
        walk->buffer = kmalloc(n, GFP_ATOMIC);
        if (!walk->buffer)
@@ -167,8 +169,8 @@ ok:
        walk->dst.virt.addr = (u8 *)ALIGN((unsigned long)walk->buffer,
                                          alignmask + 1);
        walk->dst.virt.addr = blkcipher_get_spot(walk->dst.virt.addr, bsize);
-       walk->src.virt.addr = blkcipher_get_spot(walk->dst.virt.addr + bsize,
-                                                bsize);
+       walk->src.virt.addr = blkcipher_get_spot(walk->dst.virt.addr +
+                                                aligned_bsize, bsize);
 
        scatterwalk_copychunks(walk->src.virt.addr, &walk->in, bsize, 0);
 
@@ -224,12 +226,12 @@ static int blkcipher_walk_next(struct blkcipher_desc *desc,
 {
        struct crypto_blkcipher *tfm = desc->tfm;
        unsigned int alignmask = crypto_blkcipher_alignmask(tfm);
-       unsigned int bsize = crypto_blkcipher_blocksize(tfm);
+       unsigned int bsize;
        unsigned int n;
        int err;
 
        n = walk->total;
-       if (unlikely(n < bsize)) {
+       if (unlikely(n < crypto_blkcipher_blocksize(tfm))) {
                desc->flags |= CRYPTO_TFM_RES_BAD_BLOCK_LEN;
                return blkcipher_walk_done(desc, walk, -EINVAL);
        }
@@ -246,6 +248,7 @@ static int blkcipher_walk_next(struct blkcipher_desc *desc,
                }
        }
 
+       bsize = min(walk->blocksize, n);
        n = scatterwalk_clamp(&walk->in, n);
        n = scatterwalk_clamp(&walk->out, n);
 
@@ -276,9 +279,11 @@ static inline int blkcipher_copy_iv(struct blkcipher_walk *walk,
                                    struct crypto_blkcipher *tfm,
                                    unsigned int alignmask)
 {
-       unsigned bs = crypto_blkcipher_blocksize(tfm);
+       unsigned bs = walk->blocksize;
        unsigned int ivsize = crypto_blkcipher_ivsize(tfm);
-       unsigned int size = bs * 2 + ivsize + max(bs, ivsize) - (alignmask + 1);
+       unsigned aligned_bs = ALIGN(bs, alignmask + 1);
+       unsigned int size = aligned_bs * 2 + ivsize + max(aligned_bs, ivsize) -
+                           (alignmask + 1);
        u8 *iv;
 
        size += alignmask & ~(crypto_tfm_ctx_alignment() - 1);
@@ -287,8 +292,8 @@ static inline int blkcipher_copy_iv(struct blkcipher_walk *walk,
                return -ENOMEM;
 
        iv = (u8 *)ALIGN((unsigned long)walk->buffer, alignmask + 1);
-       iv = blkcipher_get_spot(iv, bs) + bs;
-       iv = blkcipher_get_spot(iv, bs) + bs;
+       iv = blkcipher_get_spot(iv, bs) + aligned_bs;
+       iv = blkcipher_get_spot(iv, bs) + aligned_bs;
        iv = blkcipher_get_spot(iv, ivsize);
 
        walk->iv = memcpy(iv, walk->iv, ivsize);
@@ -299,6 +304,7 @@ int blkcipher_walk_virt(struct blkcipher_desc *desc,
                        struct blkcipher_walk *walk)
 {
        walk->flags &= ~BLKCIPHER_WALK_PHYS;
+       walk->blocksize = crypto_blkcipher_blocksize(desc->tfm);
        return blkcipher_walk_first(desc, walk);
 }
 EXPORT_SYMBOL_GPL(blkcipher_walk_virt);
@@ -307,6 +313,7 @@ int blkcipher_walk_phys(struct blkcipher_desc *desc,
                        struct blkcipher_walk *walk)
 {
        walk->flags |= BLKCIPHER_WALK_PHYS;
+       walk->blocksize = crypto_blkcipher_blocksize(desc->tfm);
        return blkcipher_walk_first(desc, walk);
 }
 EXPORT_SYMBOL_GPL(blkcipher_walk_phys);
@@ -339,7 +346,18 @@ static int blkcipher_walk_first(struct blkcipher_desc *desc,
        return blkcipher_walk_next(desc, walk);
 }
 
-static int setkey_unaligned(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
+int blkcipher_walk_virt_block(struct blkcipher_desc *desc,
+                             struct blkcipher_walk *walk,
+                             unsigned int blocksize)
+{
+       walk->flags &= ~BLKCIPHER_WALK_PHYS;
+       walk->blocksize = blocksize;
+       return blkcipher_walk_first(desc, walk);
+}
+EXPORT_SYMBOL_GPL(blkcipher_walk_virt_block);
+
+static int setkey_unaligned(struct crypto_tfm *tfm, const u8 *key,
+                           unsigned int keylen)
 {
        struct blkcipher_alg *cipher = &tfm->__crt_alg->cra_blkcipher;
        unsigned long alignmask = crypto_tfm_alg_alignmask(tfm);
@@ -360,8 +378,7 @@ static int setkey_unaligned(struct crypto_tfm *tfm, const u8 *key, unsigned int
        return ret;
 }
 
-static int setkey(struct crypto_tfm *tfm, const u8 *key,
-                 unsigned int keylen)
+static int setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
 {
        struct blkcipher_alg *cipher = &tfm->__crt_alg->cra_blkcipher;
        unsigned long alignmask = crypto_tfm_alg_alignmask(tfm);