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

Pull crypto fixes from Herbert Xu:
 "This fixes the following issues:

  API:
   - Fix kzalloc error path crash in ecryptfs added by skcipher
     conversion.  Note the subject of the commit is screwed up and the
     correct subject is actually in the body.

  Drivers:
   - A number of fixes to the marvell cesa hashing code.
   - Remove bogus nested irqsave that clobbers the saved flags in ccp"

* 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6:
  crypto: marvell/cesa - forward devm_ioremap_resource() error code
  crypto: marvell/cesa - initialize hash states
  crypto: marvell/cesa - fix memory leak
  crypto: ccp - fix lock acquisition code
  eCryptfs: Use skcipher and shash

diff --git a/drivers/crypto/ccp/ccp-dev.c b/drivers/crypto/ccp/ccp-dev.c
index 336e5b780fcb791c732abe2dc443ee3992809d59..4dbc187272358414e108143a0561940676de0341 100644 (file)
--- a/drivers/crypto/ccp/ccp-dev.c
+++ b/drivers/crypto/ccp/ccp-dev.c
@@ -53,7 +53,7 @@ static DEFINE_RWLOCK(ccp_unit_lock);
 static LIST_HEAD(ccp_units);
 
 /* Round-robin counter */
-static DEFINE_RWLOCK(ccp_rr_lock);
+static DEFINE_SPINLOCK(ccp_rr_lock);
 static struct ccp_device *ccp_rr;
 
 /* Ever-increasing value to produce unique unit numbers */
@@ -128,14 +128,14 @@ static struct ccp_device *ccp_get_device(void)
         */
        read_lock_irqsave(&ccp_unit_lock, flags);
        if (!list_empty(&ccp_units)) {
-               write_lock_irqsave(&ccp_rr_lock, flags);
+               spin_lock(&ccp_rr_lock);
                dp = ccp_rr;
                if (list_is_last(&ccp_rr->entry, &ccp_units))
                        ccp_rr = list_first_entry(&ccp_units, struct ccp_device,
                                                  entry);
                else
                        ccp_rr = list_next_entry(ccp_rr, entry);
-               write_unlock_irqrestore(&ccp_rr_lock, flags);
+               spin_unlock(&ccp_rr_lock);
        }
        read_unlock_irqrestore(&ccp_unit_lock, flags);
 

diff --git a/drivers/crypto/marvell/cesa.c b/drivers/crypto/marvell/cesa.c
index c0656e7f37b5993672002a8a192dc1c9dcf0c4bd..80239ae69527210ef9cabf53267d40907a8df871 100644 (file)
--- a/drivers/crypto/marvell/cesa.c
+++ b/drivers/crypto/marvell/cesa.c
@@ -420,7 +420,7 @@ static int mv_cesa_probe(struct platform_device *pdev)
        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
        cesa->regs = devm_ioremap_resource(dev, res);
        if (IS_ERR(cesa->regs))
-               return -ENOMEM;
+               return PTR_ERR(cesa->regs);
 
        ret = mv_cesa_dev_dma_init(cesa);
        if (ret)

diff --git a/drivers/crypto/marvell/cesa.h b/drivers/crypto/marvell/cesa.h
index bd985e72520b56428af796e1531cfb8771099a9c..74071e45ada0d07fbc98ccf5f61fa482b1b2166b 100644 (file)
--- a/drivers/crypto/marvell/cesa.h
+++ b/drivers/crypto/marvell/cesa.h
@@ -588,6 +588,7 @@ struct mv_cesa_ahash_dma_req {
        struct mv_cesa_tdma_req base;
        u8 *padding;
        dma_addr_t padding_dma;
+       u8 *cache;
        dma_addr_t cache_dma;
 };
 
@@ -609,7 +610,7 @@ struct mv_cesa_ahash_req {
                struct mv_cesa_ahash_std_req std;
        } req;
        struct mv_cesa_op_ctx op_tmpl;
-       u8 *cache;
+       u8 cache[CESA_MAX_HASH_BLOCK_SIZE];
        unsigned int cache_ptr;
        u64 len;
        int src_nents;

diff --git a/drivers/crypto/marvell/hash.c b/drivers/crypto/marvell/hash.c
index 683cca9ac3c46bbf8625042f2c4b5c91e7eec51f..7ca2e0f9dc2ef983d47e1a67f1cb142ef35e2e3a 100644 (file)
--- a/drivers/crypto/marvell/hash.c
+++ b/drivers/crypto/marvell/hash.c
@@ -45,69 +45,25 @@ mv_cesa_ahash_req_iter_next_op(struct mv_cesa_ahash_dma_iter *iter)
        return mv_cesa_req_dma_iter_next_op(&iter->base);
 }
 
-static inline int mv_cesa_ahash_dma_alloc_cache(struct mv_cesa_ahash_req *creq,
-                                               gfp_t flags)
+static inline int
+mv_cesa_ahash_dma_alloc_cache(struct mv_cesa_ahash_dma_req *req, gfp_t flags)
 {
-       struct mv_cesa_ahash_dma_req *dreq = &creq->req.dma;
-
-       creq->cache = dma_pool_alloc(cesa_dev->dma->cache_pool, flags,
-                                    &dreq->cache_dma);
-       if (!creq->cache)
-               return -ENOMEM;
-
-       return 0;
-}
-
-static inline int mv_cesa_ahash_std_alloc_cache(struct mv_cesa_ahash_req *creq,
-                                               gfp_t flags)
-{
-       creq->cache = kzalloc(CESA_MAX_HASH_BLOCK_SIZE, flags);
-       if (!creq->cache)
+       req->cache = dma_pool_alloc(cesa_dev->dma->cache_pool, flags,
+                                   &req->cache_dma);
+       if (!req->cache)
                return -ENOMEM;
 
        return 0;
 }
 
-static int mv_cesa_ahash_alloc_cache(struct ahash_request *req)
-{
-       struct mv_cesa_ahash_req *creq = ahash_request_ctx(req);
-       gfp_t flags = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ?
-                     GFP_KERNEL : GFP_ATOMIC;
-       int ret;
-
-       if (creq->cache)
-               return 0;
-
-       if (creq->req.base.type == CESA_DMA_REQ)
-               ret = mv_cesa_ahash_dma_alloc_cache(creq, flags);
-       else
-               ret = mv_cesa_ahash_std_alloc_cache(creq, flags);
-
-       return ret;
-}
-
-static inline void mv_cesa_ahash_dma_free_cache(struct mv_cesa_ahash_req *creq)
-{
-       dma_pool_free(cesa_dev->dma->cache_pool, creq->cache,
-                     creq->req.dma.cache_dma);
-}
-
-static inline void mv_cesa_ahash_std_free_cache(struct mv_cesa_ahash_req *creq)
-{
-       kfree(creq->cache);
-}
-
-static void mv_cesa_ahash_free_cache(struct mv_cesa_ahash_req *creq)
+static inline void
+mv_cesa_ahash_dma_free_cache(struct mv_cesa_ahash_dma_req *req)
 {
-       if (!creq->cache)
+       if (!req->cache)
                return;
 
-       if (creq->req.base.type == CESA_DMA_REQ)
-               mv_cesa_ahash_dma_free_cache(creq);
-       else
-               mv_cesa_ahash_std_free_cache(creq);
-
-       creq->cache = NULL;
+       dma_pool_free(cesa_dev->dma->cache_pool, req->cache,
+                     req->cache_dma);
 }
 
 static int mv_cesa_ahash_dma_alloc_padding(struct mv_cesa_ahash_dma_req *req,
@@ -146,6 +102,7 @@ static inline void mv_cesa_ahash_dma_cleanup(struct ahash_request *req)
        struct mv_cesa_ahash_req *creq = ahash_request_ctx(req);
 
        dma_unmap_sg(cesa_dev->dev, req->src, creq->src_nents, DMA_TO_DEVICE);
+       mv_cesa_ahash_dma_free_cache(&creq->req.dma);
        mv_cesa_dma_cleanup(&creq->req.dma.base);
 }
 
@@ -161,8 +118,6 @@ static void mv_cesa_ahash_last_cleanup(struct ahash_request *req)
 {
        struct mv_cesa_ahash_req *creq = ahash_request_ctx(req);
 
-       mv_cesa_ahash_free_cache(creq);
-
        if (creq->req.base.type == CESA_DMA_REQ)
                mv_cesa_ahash_dma_last_cleanup(req);
 }
@@ -445,14 +400,6 @@ static inline int mv_cesa_ahash_cra_init(struct crypto_tfm *tfm)
 static int mv_cesa_ahash_cache_req(struct ahash_request *req, bool *cached)
 {
        struct mv_cesa_ahash_req *creq = ahash_request_ctx(req);
-       int ret;
-
-       if (((creq->cache_ptr + req->nbytes) & CESA_HASH_BLOCK_SIZE_MSK) &&
-           !creq->last_req) {
-               ret = mv_cesa_ahash_alloc_cache(req);
-               if (ret)
-                       return ret;
-       }
 
        if (creq->cache_ptr + req->nbytes < 64 && !creq->last_req) {
                *cached = true;
@@ -505,10 +452,17 @@ mv_cesa_ahash_dma_add_cache(struct mv_cesa_tdma_chain *chain,
                            gfp_t flags)
 {
        struct mv_cesa_ahash_dma_req *ahashdreq = &creq->req.dma;
+       int ret;
 
        if (!creq->cache_ptr)
                return 0;
 
+       ret = mv_cesa_ahash_dma_alloc_cache(ahashdreq, flags);
+       if (ret)
+               return ret;
+
+       memcpy(ahashdreq->cache, creq->cache, creq->cache_ptr);
+
        return mv_cesa_dma_add_data_transfer(chain,
                                             CESA_SA_DATA_SRAM_OFFSET,
                                             ahashdreq->cache_dma,
@@ -848,10 +802,6 @@ static int mv_cesa_ahash_import(struct ahash_request *req, const void *hash,
        if (!cache_ptr)
                return 0;
 
-       ret = mv_cesa_ahash_alloc_cache(req);
-       if (ret)
-               return ret;
-
        memcpy(creq->cache, cache, cache_ptr);
        creq->cache_ptr = cache_ptr;
 
@@ -860,9 +810,14 @@ static int mv_cesa_ahash_import(struct ahash_request *req, const void *hash,
 
 static int mv_cesa_md5_init(struct ahash_request *req)
 {
+       struct mv_cesa_ahash_req *creq = ahash_request_ctx(req);
        struct mv_cesa_op_ctx tmpl = { };
 
        mv_cesa_set_op_cfg(&tmpl, CESA_SA_DESC_CFG_MACM_MD5);
+       creq->state[0] = MD5_H0;
+       creq->state[1] = MD5_H1;
+       creq->state[2] = MD5_H2;
+       creq->state[3] = MD5_H3;
 
        mv_cesa_ahash_init(req, &tmpl, true);
 
@@ -923,9 +878,15 @@ struct ahash_alg mv_md5_alg = {
 
 static int mv_cesa_sha1_init(struct ahash_request *req)
 {
+       struct mv_cesa_ahash_req *creq = ahash_request_ctx(req);
        struct mv_cesa_op_ctx tmpl = { };
 
        mv_cesa_set_op_cfg(&tmpl, CESA_SA_DESC_CFG_MACM_SHA1);
+       creq->state[0] = SHA1_H0;
+       creq->state[1] = SHA1_H1;
+       creq->state[2] = SHA1_H2;
+       creq->state[3] = SHA1_H3;
+       creq->state[4] = SHA1_H4;
 
        mv_cesa_ahash_init(req, &tmpl, false);
 
@@ -986,9 +947,18 @@ struct ahash_alg mv_sha1_alg = {
 
 static int mv_cesa_sha256_init(struct ahash_request *req)
 {
+       struct mv_cesa_ahash_req *creq = ahash_request_ctx(req);
        struct mv_cesa_op_ctx tmpl = { };
 
        mv_cesa_set_op_cfg(&tmpl, CESA_SA_DESC_CFG_MACM_SHA256);
+       creq->state[0] = SHA256_H0;
+       creq->state[1] = SHA256_H1;
+       creq->state[2] = SHA256_H2;
+       creq->state[3] = SHA256_H3;
+       creq->state[4] = SHA256_H4;
+       creq->state[5] = SHA256_H5;
+       creq->state[6] = SHA256_H6;
+       creq->state[7] = SHA256_H7;
 
        mv_cesa_ahash_init(req, &tmpl, false);
 

diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index c5c84dfb5b3e3e0cf488a38846d4897b19fd53d0..9893d15381222481e3c142b7934e8bd934cf4215 100644 (file)
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -635,8 +635,7 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
        if (!s) {
                printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
                       "[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
-               rc = -ENOMEM;
-               goto out;
+               return -ENOMEM;
        }
        (*packet_size) = 0;
        rc = ecryptfs_find_auth_tok_for_sig(
@@ -922,8 +921,7 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
        if (!s) {
                printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
                       "[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
-               rc = -ENOMEM;
-               goto out;
+               return -ENOMEM;
        }
        if (max_packet_size < ECRYPTFS_TAG_70_MIN_METADATA_SIZE) {
                printk(KERN_WARNING "%s: max_packet_size is [%zd]; it must be "