Merge branch 'pending-misc' (early part) into devel

5 files changed, 214 insertions, 105 deletions

diff --git a/crypto/async_tx/Kconfig b/crypto/async_tx/Kconfig
index e5aeb2b79e6f..e28e276ac611 100644
--- a/crypto/async_tx/Kconfig
+++ b/crypto/async_tx/Kconfig
@@ -23,3 +23,8 @@ config ASYNC_RAID6_RECOV
         select ASYNC_CORE
         select ASYNC_PQ
 
+config ASYNC_TX_DISABLE_PQ_VAL_DMA
+        bool
+
+config ASYNC_TX_DISABLE_XOR_VAL_DMA
+        bool
diff --git a/crypto/async_tx/async_pq.c b/crypto/async_tx/async_pq.c
index b88db6d1dc65..ec87f53d5059 100644
--- a/crypto/async_tx/async_pq.c
+++ b/crypto/async_tx/async_pq.c
@@ -26,14 +26,10 @@
 #include <linux/async_tx.h>
 
 /**
- * scribble - space to hold throwaway P buffer for synchronous gen_syndrome
+ * pq_scribble_page - space to hold throwaway P or Q buffer for
+ * synchronous gen_syndrome
  */
-static struct page *scribble;
-
-static bool is_raid6_zero_block(struct page *p)
-{
-        return p == (void *) raid6_empty_zero_page;
-}
+static struct page *pq_scribble_page;
 
 /* the struct page *blocks[] parameter passed to async_gen_syndrome()
  * and async_syndrome_val() contains the 'P' destination address at
@@ -83,7 +79,7 @@ do_async_gen_syndrome(struct dma_chan *chan, struct page **blocks,
          * sources and update the coefficients accordingly
          */
         for (i = 0, idx = 0; i < src_cnt; i++) {
-                if (is_raid6_zero_block(blocks[i]))
+                if (blocks[i] == NULL)
                         continue;
                 dma_src[idx] = dma_map_page(dma->dev, blocks[i], offset, len,
                                             DMA_TO_DEVICE);
@@ -160,9 +156,9 @@ do_sync_gen_syndrome(struct page **blocks, unsigned int offset, int disks,
                 srcs = (void **) blocks;
 
         for (i = 0; i < disks; i++) {
-                if (is_raid6_zero_block(blocks[i])) {
+                if (blocks[i] == NULL) {
                         BUG_ON(i > disks - 3); /* P or Q can't be zero */
-                        srcs[i] = blocks[i];
+                        srcs[i] = (void*)raid6_empty_zero_page;
                 } else
                         srcs[i] = page_address(blocks[i]) + offset;
         }
@@ -186,10 +182,14 @@ do_sync_gen_syndrome(struct page **blocks, unsigned int offset, int disks,
  * blocks[disks-1] to NULL.  When P or Q is omitted 'len' must be <=
  * PAGE_SIZE as a temporary buffer of this size is used in the
  * synchronous path.  'disks' always accounts for both destination
- * buffers.
+ * buffers.  If any source buffers (blocks[i] where i < disks - 2) are
+ * set to NULL those buffers will be replaced with the raid6_zero_page
+ * in the synchronous path and omitted in the hardware-asynchronous
+ * path.
  *
  * 'blocks' note: if submit->scribble is NULL then the contents of
- * 'blocks' may be overridden
+ * 'blocks' may be overwritten to perform address conversions
+ * (dma_map_page() or page_address()).
  */
 struct dma_async_tx_descriptor *
 async_gen_syndrome(struct page **blocks, unsigned int offset, int disks,
@@ -227,11 +227,11 @@ async_gen_syndrome(struct page **blocks, unsigned int offset, int disks,
         async_tx_quiesce(&submit->depend_tx);
 
         if (!P(blocks, disks)) {
-                P(blocks, disks) = scribble;
+                P(blocks, disks) = pq_scribble_page;
                 BUG_ON(len + offset > PAGE_SIZE);
         }
         if (!Q(blocks, disks)) {
-                Q(blocks, disks) = scribble;
+                Q(blocks, disks) = pq_scribble_page;
                 BUG_ON(len + offset > PAGE_SIZE);
         }
         do_sync_gen_syndrome(blocks, offset, disks, len, submit);
@@ -240,6 +240,16 @@ async_gen_syndrome(struct page **blocks, unsigned int offset, int disks,
 }
 EXPORT_SYMBOL_GPL(async_gen_syndrome);
 
+static inline struct dma_chan *
+pq_val_chan(struct async_submit_ctl *submit, struct page **blocks, int disks, size_t len)
+{
+        #ifdef CONFIG_ASYNC_TX_DISABLE_PQ_VAL_DMA
+        return NULL;
+        #endif
+        return async_tx_find_channel(submit, DMA_PQ_VAL, NULL, 0,  blocks,
+                                     disks, len);
+}
+
 /**
  * async_syndrome_val - asynchronously validate a raid6 syndrome
  * @blocks: source blocks from idx 0..disks-3, P @ disks-2 and Q @ disks-1
@@ -260,13 +270,13 @@ async_syndrome_val(struct page **blocks, unsigned int offset, int disks,
                    size_t len, enum sum_check_flags *pqres, struct page *spare,
                    struct async_submit_ctl *submit)
 {
-        struct dma_chan *chan = async_tx_find_channel(submit, DMA_PQ_VAL,
-                                                      NULL, 0,  blocks, disks,
-                                                      len);
+        struct dma_chan *chan = pq_val_chan(submit, blocks, disks, len);
         struct dma_device *device = chan ? chan->device : NULL;
         struct dma_async_tx_descriptor *tx;
+        unsigned char coefs[disks-2];
         enum dma_ctrl_flags dma_flags = submit->cb_fn ? DMA_PREP_INTERRUPT : 0;
         dma_addr_t *dma_src = NULL;
+        int src_cnt = 0;
 
         BUG_ON(disks < 4);
 
@@ -285,22 +295,32 @@ async_syndrome_val(struct page **blocks, unsigned int offset, int disks,
                          __func__, disks, len);
                 if (!P(blocks, disks))
                         dma_flags |= DMA_PREP_PQ_DISABLE_P;
+                else
+                        pq[0] = dma_map_page(dev, P(blocks, disks),
+                                             offset, len,
+                                             DMA_TO_DEVICE);
                 if (!Q(blocks, disks))
                         dma_flags |= DMA_PREP_PQ_DISABLE_Q;
+                else
+                        pq[1] = dma_map_page(dev, Q(blocks, disks),
+                                             offset, len,
+                                             DMA_TO_DEVICE);
+
                 if (submit->flags & ASYNC_TX_FENCE)
                         dma_flags |= DMA_PREP_FENCE;
-                for (i = 0; i < disks; i++)
+                for (i = 0; i < disks-2; i++)
                         if (likely(blocks[i])) {
-                                BUG_ON(is_raid6_zero_block(blocks[i]));
-                                dma_src[i] = dma_map_page(dev, blocks[i],
-                                                          offset, len,
-                                                          DMA_TO_DEVICE);
+                                dma_src[src_cnt] = dma_map_page(dev, blocks[i],
+                                                                offset, len,
+                                                                DMA_TO_DEVICE);
+                                coefs[src_cnt] = raid6_gfexp[i];
+                                src_cnt++;
                         }
 
                 for (;;) {
                         tx = device->device_prep_dma_pq_val(chan, pq, dma_src,
-                                                            disks - 2,
-                                                            raid6_gfexp,
+                                                            src_cnt,
+                                                            coefs,
                                                             len, pqres,
                                                             dma_flags);
                         if (likely(tx))
@@ -373,9 +393,9 @@ EXPORT_SYMBOL_GPL(async_syndrome_val);
 
 static int __init async_pq_init(void)
 {
-        scribble = alloc_page(GFP_KERNEL);
+        pq_scribble_page = alloc_page(GFP_KERNEL);
 
-        if (scribble)
+        if (pq_scribble_page)
                 return 0;
 
         pr_err("%s: failed to allocate required spare page\n", __func__);
@@ -385,7 +405,7 @@ static int __init async_pq_init(void)
 
 static void __exit async_pq_exit(void)
 {
-        put_page(scribble);
+        put_page(pq_scribble_page);
 }
 
 module_init(async_pq_init);
diff --git a/crypto/async_tx/async_raid6_recov.c b/crypto/async_tx/async_raid6_recov.c
index 6d73dde4786d..943f2abac9b4 100644
--- a/crypto/async_tx/async_raid6_recov.c
+++ b/crypto/async_tx/async_raid6_recov.c
@@ -131,8 +131,8 @@ async_mult(struct page *dest, struct page *src, u8 coef, size_t len,
 }
 
 static struct dma_async_tx_descriptor *
-__2data_recov_4(size_t bytes, int faila, int failb, struct page **blocks,
-              struct async_submit_ctl *submit)
+__2data_recov_4(int disks, size_t bytes, int faila, int failb,
+                struct page **blocks, struct async_submit_ctl *submit)
 {
         struct dma_async_tx_descriptor *tx = NULL;
         struct page *p, *q, *a, *b;
@@ -143,8 +143,8 @@ __2data_recov_4(size_t bytes, int faila, int failb, struct page **blocks,
         void *cb_param = submit->cb_param;
         void *scribble = submit->scribble;
 
-        p = blocks[4-2];
-        q = blocks[4-1];
+        p = blocks[disks-2];
+        q = blocks[disks-1];
 
         a = blocks[faila];
         b = blocks[failb];
@@ -170,8 +170,8 @@ __2data_recov_4(size_t bytes, int faila, int failb, struct page **blocks,
 }
 
 static struct dma_async_tx_descriptor *
-__2data_recov_5(size_t bytes, int faila, int failb, struct page **blocks,
-              struct async_submit_ctl *submit)
+__2data_recov_5(int disks, size_t bytes, int faila, int failb,
+                struct page **blocks, struct async_submit_ctl *submit)
 {
         struct dma_async_tx_descriptor *tx = NULL;
         struct page *p, *q, *g, *dp, *dq;
@@ -181,21 +181,22 @@ __2data_recov_5(size_t bytes, int faila, int failb, struct page **blocks,
         dma_async_tx_callback cb_fn = submit->cb_fn;
         void *cb_param = submit->cb_param;
         void *scribble = submit->scribble;
-        int uninitialized_var(good);
-        int i;
+        int good_srcs, good, i;
 
-        for (i = 0; i < 3; i++) {
+        good_srcs = 0;
+        good = -1;
+        for (i = 0; i < disks-2; i++) {
+                if (blocks[i] == NULL)
+                        continue;
                 if (i == faila || i == failb)
                         continue;
-                else {
-                        good = i;
-                        break;
-                }
+                good = i;
+                good_srcs++;
         }
-        BUG_ON(i >= 3);
+        BUG_ON(good_srcs > 1);
 
-        p = blocks[5-2];
-        q = blocks[5-1];
+        p = blocks[disks-2];
+        q = blocks[disks-1];
         g = blocks[good];
 
         /* Compute syndrome with zero for the missing data pages
@@ -263,10 +264,10 @@ __2data_recov_n(int disks, size_t bytes, int faila, int failb,
          * delta p and delta q
          */
         dp = blocks[faila];
-        blocks[faila] = (void *)raid6_empty_zero_page;
+        blocks[faila] = NULL;
         blocks[disks-2] = dp;
         dq = blocks[failb];
-        blocks[failb] = (void *)raid6_empty_zero_page;
+        blocks[failb] = NULL;
         blocks[disks-1] = dq;
 
         init_async_submit(submit, ASYNC_TX_FENCE, tx, NULL, NULL, scribble);
@@ -323,6 +324,8 @@ struct dma_async_tx_descriptor *
 async_raid6_2data_recov(int disks, size_t bytes, int faila, int failb,
                         struct page **blocks, struct async_submit_ctl *submit)
 {
+        int non_zero_srcs, i;
+
         BUG_ON(faila == failb);
         if (failb < faila)
                 swap(faila, failb);
@@ -334,11 +337,13 @@ async_raid6_2data_recov(int disks, size_t bytes, int faila, int failb,
          */
         if (!submit->scribble) {
                 void **ptrs = (void **) blocks;
-                int i;
 
                 async_tx_quiesce(&submit->depend_tx);
                 for (i = 0; i < disks; i++)
-                        ptrs[i] = page_address(blocks[i]);
+                        if (blocks[i] == NULL)
+                                ptrs[i] = (void *) raid6_empty_zero_page;
+                        else
+                                ptrs[i] = page_address(blocks[i]);
 
                 raid6_2data_recov(disks, bytes, faila, failb, ptrs);
 
@@ -347,19 +352,30 @@ async_raid6_2data_recov(int disks, size_t bytes, int faila, int failb,
                 return NULL;
         }
 
-        switch (disks) {
-        case 4:
+        non_zero_srcs = 0;
+        for (i = 0; i < disks-2 && non_zero_srcs < 4; i++)
+                if (blocks[i])
+                        non_zero_srcs++;
+        switch (non_zero_srcs) {
+        case 0:
+        case 1:
+                /* There must be at least 2 sources - the failed devices. */
+                BUG();
+
+        case 2:
                 /* dma devices do not uniformly understand a zero source pq
                  * operation (in contrast to the synchronous case), so
-                 * explicitly handle the 4 disk special case
+                 * explicitly handle the special case of a 4 disk array with
+                 * both data disks missing.
                  */
-                return __2data_recov_4(bytes, faila, failb, blocks, submit);
-        case 5:
+                return __2data_recov_4(disks, bytes, faila, failb, blocks, submit);
+        case 3:
                 /* dma devices do not uniformly understand a single
                  * source pq operation (in contrast to the synchronous
-                 * case), so explicitly handle the 5 disk special case
+                 * case), so explicitly handle the special case of a 5 disk
+                 * array with 2 of 3 data disks missing.
                  */
-                return __2data_recov_5(bytes, faila, failb, blocks, submit);
+                return __2data_recov_5(disks, bytes, faila, failb, blocks, submit);
         default:
                 return __2data_recov_n(disks, bytes, faila, failb, blocks, submit);
         }
@@ -385,6 +401,7 @@ async_raid6_datap_recov(int disks, size_t bytes, int faila,
         dma_async_tx_callback cb_fn = submit->cb_fn;
         void *cb_param = submit->cb_param;
         void *scribble = submit->scribble;
+        int good_srcs, good, i;
         struct page *srcs[2];
 
         pr_debug("%s: disks: %d len: %zu\n", __func__, disks, bytes);
@@ -394,11 +411,13 @@ async_raid6_datap_recov(int disks, size_t bytes, int faila,
          */
         if (!scribble) {
                 void **ptrs = (void **) blocks;
-                int i;
 
                 async_tx_quiesce(&submit->depend_tx);
                 for (i = 0; i < disks; i++)
-                        ptrs[i] = page_address(blocks[i]);
+                        if (blocks[i] == NULL)
+                                ptrs[i] = (void*)raid6_empty_zero_page;
+                        else
+                                ptrs[i] = page_address(blocks[i]);
 
                 raid6_datap_recov(disks, bytes, faila, ptrs);
 
@@ -407,6 +426,20 @@ async_raid6_datap_recov(int disks, size_t bytes, int faila,
                 return NULL;
         }
 
+        good_srcs = 0;
+        good = -1;
+        for (i = 0; i < disks-2; i++) {
+                if (i == faila)
+                        continue;
+                if (blocks[i]) {
+                        good = i;
+                        good_srcs++;
+                        if (good_srcs > 1)
+                                break;
+                }
+        }
+        BUG_ON(good_srcs == 0);
+
         p = blocks[disks-2];
         q = blocks[disks-1];
 
@@ -414,14 +447,13 @@ async_raid6_datap_recov(int disks, size_t bytes, int faila,
          * Use the dead data page as temporary storage for delta q
          */
         dq = blocks[faila];
-        blocks[faila] = (void *)raid6_empty_zero_page;
+        blocks[faila] = NULL;
         blocks[disks-1] = dq;
 
-        /* in the 4 disk case we only need to perform a single source
-         * multiplication
+        /* in the 4-disk case we only need to perform a single source
+         * multiplication with the one good data block.
          */
-        if (disks == 4) {
-                int good = faila == 0 ? 1 : 0;
+        if (good_srcs == 1) {
                 struct page *g = blocks[good];
 
                 init_async_submit(submit, ASYNC_TX_FENCE, tx, NULL, NULL,
diff --git a/crypto/async_tx/async_xor.c b/crypto/async_tx/async_xor.c
index b459a9034aac..079ae8ca590b 100644
--- a/crypto/async_tx/async_xor.c
+++ b/crypto/async_tx/async_xor.c
@@ -44,20 +44,23 @@ do_async_xor(struct dma_chan *chan, struct page *dest, struct page **src_list,
         void *cb_param_orig = submit->cb_param;
         enum async_tx_flags flags_orig = submit->flags;
         enum dma_ctrl_flags dma_flags;
-        int xor_src_cnt;
+        int xor_src_cnt = 0;
         dma_addr_t dma_dest;
 
         /* map the dest bidrectional in case it is re-used as a source */
         dma_dest = dma_map_page(dma->dev, dest, offset, len, DMA_BIDIRECTIONAL);
         for (i = 0; i < src_cnt; i++) {
                 /* only map the dest once */
+                if (!src_list[i])
+                        continue;
                 if (unlikely(src_list[i] == dest)) {
-                        dma_src[i] = dma_dest;
+                        dma_src[xor_src_cnt++] = dma_dest;
                         continue;
                 }
-                dma_src[i] = dma_map_page(dma->dev, src_list[i], offset,
-                                          len, DMA_TO_DEVICE);
+                dma_src[xor_src_cnt++] = dma_map_page(dma->dev, src_list[i], offset,
+                                                      len, DMA_TO_DEVICE);
         }
+        src_cnt = xor_src_cnt;
 
         while (src_cnt) {
                 submit->flags = flags_orig;
@@ -123,7 +126,7 @@ do_sync_xor(struct page *dest, struct page **src_list, unsigned int offset,
             int src_cnt, size_t len, struct async_submit_ctl *submit)
 {
         int i;
-        int xor_src_cnt;
+        int xor_src_cnt = 0;
         int src_off = 0;
         void *dest_buf;
         void **srcs;
@@ -135,8 +138,9 @@ do_sync_xor(struct page *dest, struct page **src_list, unsigned int offset,
 
         /* convert to buffer pointers */
         for (i = 0; i < src_cnt; i++)
-                srcs[i] = page_address(src_list[i]) + offset;
-
+                if (src_list[i])
+                        srcs[xor_src_cnt++] = page_address(src_list[i]) + offset;
+        src_cnt = xor_src_cnt;
         /* set destination address */
         dest_buf = page_address(dest) + offset;
 
@@ -230,6 +234,17 @@ static int page_is_zero(struct page *p, unsigned int offset, size_t len)
                 memcmp(a, a + 4, len - 4) == 0);
 }
 
+static inline struct dma_chan *
+xor_val_chan(struct async_submit_ctl *submit, struct page *dest,
+                 struct page **src_list, int src_cnt, size_t len)
+{
+        #ifdef CONFIG_ASYNC_TX_DISABLE_XOR_VAL_DMA
+        return NULL;
+        #endif
+        return async_tx_find_channel(submit, DMA_XOR_VAL, &dest, 1, src_list,
+                                     src_cnt, len);
+}
+
 /**
  * async_xor_val - attempt a xor parity check with a dma engine.
  * @dest: destination page used if the xor is performed synchronously
@@ -251,9 +266,7 @@ async_xor_val(struct page *dest, struct page **src_list, unsigned int offset,
               int src_cnt, size_t len, enum sum_check_flags *result,
               struct async_submit_ctl *submit)
 {
-        struct dma_chan *chan = async_tx_find_channel(submit, DMA_XOR_VAL,
-                                                      &dest, 1, src_list,
-                                                      src_cnt, len);
+        struct dma_chan *chan = xor_val_chan(submit, dest, src_list, src_cnt, len);
         struct dma_device *device = chan ? chan->device : NULL;
         struct dma_async_tx_descriptor *tx = NULL;
         dma_addr_t *dma_src = NULL;
diff --git a/crypto/gcm.c b/crypto/gcm.c
index 5fc3292483ef..c6547130624c 100644
--- a/crypto/gcm.c
+++ b/crypto/gcm.c
@@ -40,7 +40,7 @@ struct crypto_rfc4106_ctx {
 struct crypto_gcm_ghash_ctx {
         unsigned int cryptlen;
         struct scatterlist *src;
-        crypto_completion_t complete;
+        void (*complete)(struct aead_request *req, int err);
 };
 
 struct crypto_gcm_req_priv_ctx {
@@ -267,23 +267,26 @@ static int gcm_hash_final(struct aead_request *req,
         return crypto_ahash_final(ahreq);
 }
 
-static void gcm_hash_final_done(struct crypto_async_request *areq,
-                                int err)
+static void __gcm_hash_final_done(struct aead_request *req, int err)
 {
-        struct aead_request *req = areq->data;
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
         struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;
 
         if (!err)
                 crypto_xor(pctx->auth_tag, pctx->iauth_tag, 16);
 
-        gctx->complete(areq, err);
+        gctx->complete(req, err);
 }
 
-static void gcm_hash_len_done(struct crypto_async_request *areq,
-                              int err)
+static void gcm_hash_final_done(struct crypto_async_request *areq, int err)
 {
         struct aead_request *req = areq->data;
+
+        __gcm_hash_final_done(req, err);
+}
+
+static void __gcm_hash_len_done(struct aead_request *req, int err)
+{
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
 
         if (!err) {
@@ -292,13 +295,18 @@ static void gcm_hash_len_done(struct crypto_async_request *areq,
                         return;
         }
 
-        gcm_hash_final_done(areq, err);
+        __gcm_hash_final_done(req, err);
 }
 
-static void gcm_hash_crypt_remain_done(struct crypto_async_request *areq,
-                                       int err)
+static void gcm_hash_len_done(struct crypto_async_request *areq, int err)
 {
         struct aead_request *req = areq->data;
+
+        __gcm_hash_len_done(req, err);
+}
+
+static void __gcm_hash_crypt_remain_done(struct aead_request *req, int err)
+{
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
 
         if (!err) {
@@ -307,13 +315,19 @@ static void gcm_hash_crypt_remain_done(struct crypto_async_request *areq,
                         return;
         }
 
-        gcm_hash_len_done(areq, err);
+        __gcm_hash_len_done(req, err);
 }
 
-static void gcm_hash_crypt_done(struct crypto_async_request *areq,
-                                int err)
+static void gcm_hash_crypt_remain_done(struct crypto_async_request *areq,
+                                       int err)
 {
         struct aead_request *req = areq->data;
+
+        __gcm_hash_crypt_remain_done(req, err);
+}
+
+static void __gcm_hash_crypt_done(struct aead_request *req, int err)
+{
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
         struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;
         unsigned int remain;
@@ -327,13 +341,18 @@ static void gcm_hash_crypt_done(struct crypto_async_request *areq,
                         return;
         }
 
-        gcm_hash_crypt_remain_done(areq, err);
+        __gcm_hash_crypt_remain_done(req, err);
 }
 
-static void gcm_hash_assoc_remain_done(struct crypto_async_request *areq,
-                                           int err)
+static void gcm_hash_crypt_done(struct crypto_async_request *areq, int err)
 {
         struct aead_request *req = areq->data;
+
+        __gcm_hash_crypt_done(req, err);
+}
+
+static void __gcm_hash_assoc_remain_done(struct aead_request *req, int err)
+{
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
         struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;
         crypto_completion_t complete;
@@ -350,15 +369,21 @@ static void gcm_hash_assoc_remain_done(struct crypto_async_request *areq,
         }
 
         if (remain)
-                gcm_hash_crypt_done(areq, err);
+                __gcm_hash_crypt_done(req, err);
         else
-                gcm_hash_crypt_remain_done(areq, err);
+                __gcm_hash_crypt_remain_done(req, err);
 }
 
-static void gcm_hash_assoc_done(struct crypto_async_request *areq,
-                                int err)
+static void gcm_hash_assoc_remain_done(struct crypto_async_request *areq,
+                                       int err)
 {
         struct aead_request *req = areq->data;
+
+        __gcm_hash_assoc_remain_done(req, err);
+}
+
+static void __gcm_hash_assoc_done(struct aead_request *req, int err)
+{
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
         unsigned int remain;
 
@@ -371,13 +396,18 @@ static void gcm_hash_assoc_done(struct crypto_async_request *areq,
                         return;
         }
 
-        gcm_hash_assoc_remain_done(areq, err);
+        __gcm_hash_assoc_remain_done(req, err);
 }
 
-static void gcm_hash_init_done(struct crypto_async_request *areq,
-                               int err)
+static void gcm_hash_assoc_done(struct crypto_async_request *areq, int err)
 {
         struct aead_request *req = areq->data;
+
+        __gcm_hash_assoc_done(req, err);
+}
+
+static void __gcm_hash_init_done(struct aead_request *req, int err)
+{
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
         crypto_completion_t complete;
         unsigned int remain = 0;
@@ -393,9 +423,16 @@ static void gcm_hash_init_done(struct crypto_async_request *areq,
         }
 
         if (remain)
-                gcm_hash_assoc_done(areq, err);
+                __gcm_hash_assoc_done(req, err);
         else
-                gcm_hash_assoc_remain_done(areq, err);
+                __gcm_hash_assoc_remain_done(req, err);
+}
+
+static void gcm_hash_init_done(struct crypto_async_request *areq, int err)
+{
+        struct aead_request *req = areq->data;
+
+        __gcm_hash_init_done(req, err);
 }
 
 static int gcm_hash(struct aead_request *req,
@@ -457,10 +494,8 @@ static void gcm_enc_copy_hash(struct aead_request *req,
                                  crypto_aead_authsize(aead), 1);
 }
 
-static void gcm_enc_hash_done(struct crypto_async_request *areq,
-                                     int err)
+static void gcm_enc_hash_done(struct aead_request *req, int err)
 {
-        struct aead_request *req = areq->data;
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
 
         if (!err)
@@ -469,8 +504,7 @@ static void gcm_enc_hash_done(struct crypto_async_request *areq,
         aead_request_complete(req, err);
 }
 
-static void gcm_encrypt_done(struct crypto_async_request *areq,
-                                     int err)
+static void gcm_encrypt_done(struct crypto_async_request *areq, int err)
 {
         struct aead_request *req = areq->data;
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
@@ -479,9 +513,13 @@ static void gcm_encrypt_done(struct crypto_async_request *areq,
                 err = gcm_hash(req, pctx);
                 if (err == -EINPROGRESS || err == -EBUSY)
                         return;
+                else if (!err) {
+                        crypto_xor(pctx->auth_tag, pctx->iauth_tag, 16);
+                        gcm_enc_copy_hash(req, pctx);
+                }
         }
 
-        gcm_enc_hash_done(areq, err);
+        aead_request_complete(req, err);
 }
 
 static int crypto_gcm_encrypt(struct aead_request *req)
@@ -538,9 +576,8 @@ static void gcm_decrypt_done(struct crypto_async_request *areq, int err)
         aead_request_complete(req, err);
 }
 
-static void gcm_dec_hash_done(struct crypto_async_request *areq, int err)
+static void gcm_dec_hash_done(struct aead_request *req, int err)
 {
-        struct aead_request *req = areq->data;
         struct crypto_gcm_req_priv_ctx *pctx = crypto_gcm_reqctx(req);
         struct ablkcipher_request *abreq = &pctx->u.abreq;
         struct crypto_gcm_ghash_ctx *gctx = &pctx->ghash_ctx;
@@ -552,9 +589,11 @@ static void gcm_dec_hash_done(struct crypto_async_request *areq, int err)
                 err = crypto_ablkcipher_decrypt(abreq);
                 if (err == -EINPROGRESS || err == -EBUSY)
                         return;
+                else if (!err)
+                        err = crypto_gcm_verify(req, pctx);
         }
 
-        gcm_decrypt_done(areq, err);
+        aead_request_complete(req, err);
 }
 
 static int crypto_gcm_decrypt(struct aead_request *req)