async_xor: permit callers to pass in a 'dma/page scribble' region

async_xor() needs space to perform dma and page address conversions.  In
most cases the code can simply reuse the struct page * array because the
size of the native pointer matches the size of a dma/page address.  In
order to support archs where sizeof(dma_addr_t) is larger than
sizeof(struct page *), or to preserve the input parameters, we utilize a
memory region passed in by the caller.

Since the code is now prepared to handle the case where it cannot
perform address conversions on the stack, we no longer need the
!HIGHMEM64G dependency in drivers/dma/Kconfig.

[ Impact: don't clobber input buffers for address conversions ]

Reviewed-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, 28 insertions, 15 deletions

diff --git a/Documentation/crypto/async-tx-api.txt b/Documentation/crypto/async-tx-api.txt
index dfe0475f7919..6b15e488c0e7 100644
--- a/Documentation/crypto/async-tx-api.txt
+++ b/Documentation/crypto/async-tx-api.txt
@@ -115,29 +115,42 @@ of an operation.
 Perform a xor->copy->xor operation where each operation depends on the
 result from the previous operation:
 
-void complete_xor_copy_xor(void *param)
+void callback(void *param)
 {
-        printk("complete\n");
+        struct completion *cmp = param;
+
+        complete(cmp);
 }
 
-int run_xor_copy_xor(struct page **xor_srcs,
-                     int xor_src_cnt,
-                     struct page *xor_dest,
-                     size_t xor_len,
-                     struct page *copy_src,
-                     struct page *copy_dest,
-                     size_t copy_len)
+void run_xor_copy_xor(struct page **xor_srcs,
+                      int xor_src_cnt,
+                      struct page *xor_dest,
+                      size_t xor_len,
+                      struct page *copy_src,
+                      struct page *copy_dest,
+                      size_t copy_len)
 {
         struct dma_async_tx_descriptor *tx;
+        addr_conv_t addr_conv[xor_src_cnt];
+        struct async_submit_ctl submit;
+        addr_conv_t addr_conv[NDISKS];
+        struct completion cmp;
+
+        init_async_submit(&submit, ASYNC_TX_XOR_DROP_DST, NULL, NULL, NULL,
+                          addr_conv);
+        tx = async_xor(xor_dest, xor_srcs, 0, xor_src_cnt, xor_len, &submit)
 
-        tx = async_xor(xor_dest, xor_srcs, 0, xor_src_cnt, xor_len,
-                       ASYNC_TX_XOR_DROP_DST, NULL, NULL, NULL);
-        tx = async_memcpy(copy_dest, copy_src, 0, 0, copy_len, tx, NULL, NULL);
-        tx = async_xor(xor_dest, xor_srcs, 0, xor_src_cnt, xor_len,
-                       ASYNC_TX_XOR_DROP_DST | ASYNC_TX_ACK,
-                       tx, complete_xor_copy_xor, NULL);
+        submit->depend_tx = tx;
+        tx = async_memcpy(copy_dest, copy_src, 0, 0, copy_len, &submit);
+
+        init_completion(&cmp);
+        init_async_submit(&submit, ASYNC_TX_XOR_DROP_DST | ASYNC_TX_ACK, tx,
+                          callback, &cmp, addr_conv);
+        tx = async_xor(xor_dest, xor_srcs, 0, xor_src_cnt, xor_len, &submit);
 
         async_tx_issue_pending_all();
+
+        wait_for_completion(&cmp);
 }
 
 See include/linux/async_tx.h for more information on the flags.  See the