ioatdma: fix "ioatdma frees DMA memory with wrong function"
authorMaciej Sosnowski <maciej.sosnowski@intel.com>
Thu, 23 Apr 2009 10:31:51 +0000 (12:31 +0200)
committerDan Williams <dan.j.williams@intel.com>
Tue, 12 May 2009 21:41:47 +0000 (14:41 -0700)
as reported by Alexander Beregalov <a.beregalov@gmail.com>

ioatdma 0000:00:08.0: DMA-API: device driver frees DMA memory with
wrong function [device address=0x000000007f76f800] [size=2000 bytes]
[map
ped as single] [unmapped as page]

The ioatdma driver was unmapping all regions
(either allocated as page or single) using unmap_page.
This patch lets dma driver recognize if unmap_single or unmap_page should be used.
It introduces two new dma control flags:
DMA_COMPL_SRC_UNMAP_SINGLE and DMA_COMPL_DEST_UNMAP_SINGLE.
They should be set to indicate dma driver to do dma-unmapping as single
(first one for the source, tha latter for the destination).
If respective flag is not set, the driver assumes dma-unmapping as page.

Signed-off-by: Maciej Sosnowski <maciej.sosnowski@intel.com>
Reported-by: Alexander Beregalov <a.beregalov@gmail.com>
Tested-by: Alexander Beregalov <a.beregalov@gmail.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
drivers/dma/dmaengine.c
drivers/dma/ioat_dma.c
include/linux/dmaengine.h

index 92438e9dacc35887bd2d8b493ea3d93ac3bc20f7..5a87384ea4ff5cf58c77b64200a621b8fe616b76 100644 (file)
@@ -804,11 +804,14 @@ dma_async_memcpy_buf_to_buf(struct dma_chan *chan, void *dest,
        dma_addr_t dma_dest, dma_src;
        dma_cookie_t cookie;
        int cpu;
+       unsigned long flags;
 
        dma_src = dma_map_single(dev->dev, src, len, DMA_TO_DEVICE);
        dma_dest = dma_map_single(dev->dev, dest, len, DMA_FROM_DEVICE);
-       tx = dev->device_prep_dma_memcpy(chan, dma_dest, dma_src, len,
-                                        DMA_CTRL_ACK);
+       flags = DMA_CTRL_ACK |
+               DMA_COMPL_SRC_UNMAP_SINGLE |
+               DMA_COMPL_DEST_UNMAP_SINGLE;
+       tx = dev->device_prep_dma_memcpy(chan, dma_dest, dma_src, len, flags);
 
        if (!tx) {
                dma_unmap_single(dev->dev, dma_src, len, DMA_TO_DEVICE);
@@ -850,11 +853,12 @@ dma_async_memcpy_buf_to_pg(struct dma_chan *chan, struct page *page,
        dma_addr_t dma_dest, dma_src;
        dma_cookie_t cookie;
        int cpu;
+       unsigned long flags;
 
        dma_src = dma_map_single(dev->dev, kdata, len, DMA_TO_DEVICE);
        dma_dest = dma_map_page(dev->dev, page, offset, len, DMA_FROM_DEVICE);
-       tx = dev->device_prep_dma_memcpy(chan, dma_dest, dma_src, len,
-                                        DMA_CTRL_ACK);
+       flags = DMA_CTRL_ACK | DMA_COMPL_SRC_UNMAP_SINGLE;
+       tx = dev->device_prep_dma_memcpy(chan, dma_dest, dma_src, len, flags);
 
        if (!tx) {
                dma_unmap_single(dev->dev, dma_src, len, DMA_TO_DEVICE);
@@ -898,12 +902,13 @@ dma_async_memcpy_pg_to_pg(struct dma_chan *chan, struct page *dest_pg,
        dma_addr_t dma_dest, dma_src;
        dma_cookie_t cookie;
        int cpu;
+       unsigned long flags;
 
        dma_src = dma_map_page(dev->dev, src_pg, src_off, len, DMA_TO_DEVICE);
        dma_dest = dma_map_page(dev->dev, dest_pg, dest_off, len,
                                DMA_FROM_DEVICE);
-       tx = dev->device_prep_dma_memcpy(chan, dma_dest, dma_src, len,
-                                        DMA_CTRL_ACK);
+       flags = DMA_CTRL_ACK;
+       tx = dev->device_prep_dma_memcpy(chan, dma_dest, dma_src, len, flags);
 
        if (!tx) {
                dma_unmap_page(dev->dev, dma_src, len, DMA_TO_DEVICE);
index e4fc33c1c32f89fc99711ca2c759f15e79eeaa62..1955ee8d6d2019df1e3b9182b6abb54a2823f587 100644 (file)
@@ -1063,22 +1063,31 @@ static void ioat_dma_cleanup_tasklet(unsigned long data)
 static void
 ioat_dma_unmap(struct ioat_dma_chan *ioat_chan, struct ioat_desc_sw *desc)
 {
-       /*
-        * yes we are unmapping both _page and _single
-        * alloc'd regions with unmap_page. Is this
-        * *really* that bad?
-        */
-       if (!(desc->async_tx.flags & DMA_COMPL_SKIP_DEST_UNMAP))
-               pci_unmap_page(ioat_chan->device->pdev,
-                               pci_unmap_addr(desc, dst),
-                               pci_unmap_len(desc, len),
-                               PCI_DMA_FROMDEVICE);
-
-       if (!(desc->async_tx.flags & DMA_COMPL_SKIP_SRC_UNMAP))
-               pci_unmap_page(ioat_chan->device->pdev,
-                               pci_unmap_addr(desc, src),
-                               pci_unmap_len(desc, len),
-                               PCI_DMA_TODEVICE);
+       if (!(desc->async_tx.flags & DMA_COMPL_SKIP_DEST_UNMAP)) {
+               if (desc->async_tx.flags & DMA_COMPL_DEST_UNMAP_SINGLE)
+                       pci_unmap_single(ioat_chan->device->pdev,
+                                        pci_unmap_addr(desc, dst),
+                                        pci_unmap_len(desc, len),
+                                        PCI_DMA_FROMDEVICE);
+               else
+                       pci_unmap_page(ioat_chan->device->pdev,
+                                      pci_unmap_addr(desc, dst),
+                                      pci_unmap_len(desc, len),
+                                      PCI_DMA_FROMDEVICE);
+       }
+
+       if (!(desc->async_tx.flags & DMA_COMPL_SKIP_SRC_UNMAP)) {
+               if (desc->async_tx.flags & DMA_COMPL_SRC_UNMAP_SINGLE)
+                       pci_unmap_single(ioat_chan->device->pdev,
+                                        pci_unmap_addr(desc, src),
+                                        pci_unmap_len(desc, len),
+                                        PCI_DMA_TODEVICE);
+               else
+                       pci_unmap_page(ioat_chan->device->pdev,
+                                      pci_unmap_addr(desc, src),
+                                      pci_unmap_len(desc, len),
+                                      PCI_DMA_TODEVICE);
+       }
 }
 
 /**
@@ -1363,6 +1372,7 @@ static int ioat_dma_self_test(struct ioatdma_device *device)
        int err = 0;
        struct completion cmp;
        unsigned long tmo;
+       unsigned long flags;
 
        src = kzalloc(sizeof(u8) * IOAT_TEST_SIZE, GFP_KERNEL);
        if (!src)
@@ -1392,8 +1402,9 @@ static int ioat_dma_self_test(struct ioatdma_device *device)
                                 DMA_TO_DEVICE);
        dma_dest = dma_map_single(dma_chan->device->dev, dest, IOAT_TEST_SIZE,
                                  DMA_FROM_DEVICE);
+       flags = DMA_COMPL_SRC_UNMAP_SINGLE | DMA_COMPL_DEST_UNMAP_SINGLE;
        tx = device->common.device_prep_dma_memcpy(dma_chan, dma_dest, dma_src,
-                                                  IOAT_TEST_SIZE, 0);
+                                                  IOAT_TEST_SIZE, flags);
        if (!tx) {
                dev_err(&device->pdev->dev,
                        "Self-test prep failed, disabling\n");
index 2e2aa3df170cfb5f2be5f8097ee9e2324c759143..ffefba81c818ccc7424b54fade9f8af2a1eea10d 100644 (file)
@@ -78,12 +78,18 @@ enum dma_transaction_type {
  *     dependency chains
  * @DMA_COMPL_SKIP_SRC_UNMAP - set to disable dma-unmapping the source buffer(s)
  * @DMA_COMPL_SKIP_DEST_UNMAP - set to disable dma-unmapping the destination(s)
+ * @DMA_COMPL_SRC_UNMAP_SINGLE - set to do the source dma-unmapping as single
+ *     (if not set, do the source dma-unmapping as page)
+ * @DMA_COMPL_DEST_UNMAP_SINGLE - set to do the destination dma-unmapping as single
+ *     (if not set, do the destination dma-unmapping as page)
  */
 enum dma_ctrl_flags {
        DMA_PREP_INTERRUPT = (1 << 0),
        DMA_CTRL_ACK = (1 << 1),
        DMA_COMPL_SKIP_SRC_UNMAP = (1 << 2),
        DMA_COMPL_SKIP_DEST_UNMAP = (1 << 3),
+       DMA_COMPL_SRC_UNMAP_SINGLE = (1 << 4),
+       DMA_COMPL_DEST_UNMAP_SINGLE = (1 << 5),
 };
 
 /**