async_tx: structify submission arguments, add scribble

Prepare the api for the arrival of a new parameter, 'scribble'.  This
will allow callers to identify scratchpad memory for dma address or page
address conversions.  As this adds yet another parameter, take this
opportunity to convert the common submission parameters (flags,
dependency, callback, and callback argument) into an object that is
passed by reference.

Also, take this opportunity to fix up the kerneldoc and add notes about
the relevant ASYNC_TX_* flags for each routine.

[ Impact: moves api pass-by-value parameters to a pass-by-reference struct ]

Signed-off-by: Andre Noll <maan@systemlinux.org>
Acked-by: Maciej Sosnowski <maciej.sosnowski@intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>

1 files changed, 34 insertions, 25 deletions

diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 0ef5362c8d02..e1920f23579f 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -499,11 +499,14 @@ async_copy_data(int frombio, struct bio *bio, struct page *page,
         struct page *bio_page;
         int i;
         int page_offset;
+        struct async_submit_ctl submit;
 
         if (bio->bi_sector >= sector)
                 page_offset = (signed)(bio->bi_sector - sector) * 512;
         else
                 page_offset = (signed)(sector - bio->bi_sector) * -512;
+
+        init_async_submit(&submit, 0, tx, NULL, NULL, NULL);
         bio_for_each_segment(bvl, bio, i) {
                 int len = bio_iovec_idx(bio, i)->bv_len;
                 int clen;
@@ -525,13 +528,14 @@ async_copy_data(int frombio, struct bio *bio, struct page *page,
                         bio_page = bio_iovec_idx(bio, i)->bv_page;
                         if (frombio)
                                 tx = async_memcpy(page, bio_page, page_offset,
-                                                  b_offset, clen, 0,
-                                                  tx, NULL, NULL);
+                                                  b_offset, clen, &submit);
                         else
                                 tx = async_memcpy(bio_page, page, b_offset,
-                                                  page_offset, clen, 0,
-                                                  tx, NULL, NULL);
+                                                  page_offset, clen, &submit);
                 }
+                /* chain the operations */
+                submit.depend_tx = tx;
+
                 if (clen < len) /* hit end of page */
                         break;
                 page_offset +=  len;
@@ -590,6 +594,7 @@ static void ops_run_biofill(struct stripe_head *sh)
 {
         struct dma_async_tx_descriptor *tx = NULL;
         raid5_conf_t *conf = sh->raid_conf;
+        struct async_submit_ctl submit;
         int i;
 
         pr_debug("%s: stripe %llu\n", __func__,
@@ -613,7 +618,8 @@ static void ops_run_biofill(struct stripe_head *sh)
         }
 
         atomic_inc(&sh->count);
-        async_trigger_callback(ASYNC_TX_ACK, tx, ops_complete_biofill, sh);
+        init_async_submit(&submit, ASYNC_TX_ACK, tx, ops_complete_biofill, sh, NULL);
+        async_trigger_callback(&submit);
 }
 
 static void ops_complete_compute5(void *stripe_head_ref)
@@ -645,6 +651,7 @@ static struct dma_async_tx_descriptor *ops_run_compute5(struct stripe_head *sh)
         struct page *xor_dest = tgt->page;
         int count = 0;
         struct dma_async_tx_descriptor *tx;
+        struct async_submit_ctl submit;
         int i;
 
         pr_debug("%s: stripe %llu block: %d\n",
@@ -657,13 +664,12 @@ static struct dma_async_tx_descriptor *ops_run_compute5(struct stripe_head *sh)
 
         atomic_inc(&sh->count);
 
+        init_async_submit(&submit, ASYNC_TX_XOR_ZERO_DST, NULL,
+                          ops_complete_compute5, sh, NULL);
         if (unlikely(count == 1))
-                tx = async_memcpy(xor_dest, xor_srcs[0], 0, 0, STRIPE_SIZE,
-                        0, NULL, ops_complete_compute5, sh);
+                tx = async_memcpy(xor_dest, xor_srcs[0], 0, 0, STRIPE_SIZE, &submit);
         else
-                tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
-                        ASYNC_TX_XOR_ZERO_DST, NULL,
-                        ops_complete_compute5, sh);
+                tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE, &submit);
 
         return tx;
 }
@@ -683,6 +689,7 @@ ops_run_prexor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
         int disks = sh->disks;
         struct page *xor_srcs[disks];
         int count = 0, pd_idx = sh->pd_idx, i;
+        struct async_submit_ctl submit;
 
         /* existing parity data subtracted */
         struct page *xor_dest = xor_srcs[count++] = sh->dev[pd_idx].page;
@@ -697,9 +704,9 @@ ops_run_prexor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
                         xor_srcs[count++] = dev->page;
         }
 
-        tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
-                       ASYNC_TX_XOR_DROP_DST, tx,
-                       ops_complete_prexor, sh);
+        init_async_submit(&submit, ASYNC_TX_XOR_DROP_DST, tx,
+                          ops_complete_prexor, sh, NULL);
+        tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE, &submit);
 
         return tx;
 }
@@ -772,7 +779,7 @@ ops_run_postxor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
         /* kernel stack size limits the total number of disks */
         int disks = sh->disks;
         struct page *xor_srcs[disks];
-
+        struct async_submit_ctl submit;
         int count = 0, pd_idx = sh->pd_idx, i;
         struct page *xor_dest;
         int prexor = 0;
@@ -811,13 +818,11 @@ ops_run_postxor(struct stripe_head *sh, struct dma_async_tx_descriptor *tx)
 
         atomic_inc(&sh->count);
 
-        if (unlikely(count == 1)) {
-                flags &= ~(ASYNC_TX_XOR_DROP_DST | ASYNC_TX_XOR_ZERO_DST);
-                tx = async_memcpy(xor_dest, xor_srcs[0], 0, 0, STRIPE_SIZE,
-                        flags, tx, ops_complete_postxor, sh);
-        } else
-                tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
-                        flags, tx, ops_complete_postxor, sh);
+        init_async_submit(&submit, flags, tx, ops_complete_postxor, sh, NULL);
+        if (unlikely(count == 1))
+                tx = async_memcpy(xor_dest, xor_srcs[0], 0, 0, STRIPE_SIZE, &submit);
+        else
+                tx = async_xor(xor_dest, xor_srcs, 0, count, STRIPE_SIZE, &submit);
 }
 
 static void ops_complete_check(void *stripe_head_ref)
@@ -838,6 +843,7 @@ static void ops_run_check(struct stripe_head *sh)
         int disks = sh->disks;
         struct page *xor_srcs[disks];
         struct dma_async_tx_descriptor *tx;
+        struct async_submit_ctl submit;
 
         int count = 0, pd_idx = sh->pd_idx, i;
         struct page *xor_dest = xor_srcs[count++] = sh->dev[pd_idx].page;
@@ -851,12 +857,13 @@ static void ops_run_check(struct stripe_head *sh)
                         xor_srcs[count++] = dev->page;
         }
 
+        init_async_submit(&submit, 0, NULL, NULL, NULL, NULL);
         tx = async_xor_val(xor_dest, xor_srcs, 0, count, STRIPE_SIZE,
-                &sh->ops.zero_sum_result, 0, NULL, NULL, NULL);
+                           &sh->ops.zero_sum_result, &submit);
 
         atomic_inc(&sh->count);
-        tx = async_trigger_callback(ASYNC_TX_ACK, tx,
-                ops_complete_check, sh);
+        init_async_submit(&submit, ASYNC_TX_ACK, tx, ops_complete_check, sh, NULL);
+        tx = async_trigger_callback(&submit);
 }
 
 static void raid5_run_ops(struct stripe_head *sh, unsigned long ops_request)
@@ -2664,6 +2671,7 @@ static void handle_stripe_expansion(raid5_conf_t *conf, struct stripe_head *sh,
                 if (i != sh->pd_idx && i != sh->qd_idx) {
                         int dd_idx, j;
                         struct stripe_head *sh2;
+                        struct async_submit_ctl submit;
 
                         sector_t bn = compute_blocknr(sh, i, 1);
                         sector_t s = raid5_compute_sector(conf, bn, 0,
@@ -2683,9 +2691,10 @@ static void handle_stripe_expansion(raid5_conf_t *conf, struct stripe_head *sh,
                         }
 
                         /* place all the copies on one channel */
+                        init_async_submit(&submit, 0, tx, NULL, NULL, NULL);
                         tx = async_memcpy(sh2->dev[dd_idx].page,
                                           sh->dev[i].page, 0, 0, STRIPE_SIZE,
-                                          0, tx, NULL, NULL);
+                                          &submit);
 
                         set_bit(R5_Expanded, &sh2->dev[dd_idx].flags);
                         set_bit(R5_UPTODATE, &sh2->dev[dd_idx].flags);