powerpc/iommu/powernv: Release replaced TCE

At the moment writing new TCE value to the IOMMU table fails with EBUSY
if there is a valid entry already. However PAPR specification allows
the guest to write new TCE value without clearing it first.

Another problem this patch is addressing is the use of pool locks for
external IOMMU users such as VFIO. The pool locks are to protect
DMA page allocator rather than entries and since the host kernel does
not control what pages are in use, there is no point in pool locks and
exchange()+put_page(oldtce) is sufficient to avoid possible races.

This adds an exchange() callback to iommu_table_ops which does the same
thing as set() plus it returns replaced TCE and DMA direction so
the caller can release the pages afterwards. The exchange() receives
a physical address unlike set() which receives linear mapping address;
and returns a physical address as the clear() does.

This implements exchange() for P5IOC2/IODA/IODA2. This adds a requirement
for a platform to have exchange() implemented in order to support VFIO.

This replaces iommu_tce_build() and iommu_clear_tce() with
a single iommu_tce_xchg().

This makes sure that TCE permission bits are not set in TCE passed to
IOMMU API as those are to be calculated by platform code from
DMA direction.

This moves SetPageDirty() to the IOMMU code to make it work for both
VFIO ioctl interface in in-kernel TCE acceleration (when it becomes
available later).

Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
[aw: for the vfio related changes]
Acked-by: Alex Williamson <alex.williamson@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>

1 files changed, 38 insertions, 25 deletions

diff --git a/drivers/vfio/vfio_iommu_spapr_tce.c b/drivers/vfio/vfio_iommu_spapr_tce.c
index 9c720de46c33..a9e2d13c03c0 100644
--- a/drivers/vfio/vfio_iommu_spapr_tce.c
+++ b/drivers/vfio/vfio_iommu_spapr_tce.c
@@ -236,18 +236,11 @@ static void tce_iommu_release(void *iommu_data)
 }
 
 static void tce_iommu_unuse_page(struct tce_container *container,
-                unsigned long oldtce)
+                unsigned long hpa)
 {
         struct page *page;
 
-        if (!(oldtce & (TCE_PCI_READ | TCE_PCI_WRITE)))
-                return;
-
-        page = pfn_to_page(oldtce >> PAGE_SHIFT);
-
-        if (oldtce & TCE_PCI_WRITE)
-                SetPageDirty(page);
-
+        page = pfn_to_page(hpa >> PAGE_SHIFT);
         put_page(page);
 }
 
@@ -255,14 +248,21 @@ static int tce_iommu_clear(struct tce_container *container,
                 struct iommu_table *tbl,
                 unsigned long entry, unsigned long pages)
 {
-        unsigned long oldtce;
+        unsigned long oldhpa;
+        long ret;
+        enum dma_data_direction direction;
 
         for ( ; pages; --pages, ++entry) {
-                oldtce = iommu_clear_tce(tbl, entry);
-                if (!oldtce)
+                direction = DMA_NONE;
+                oldhpa = 0;
+                ret = iommu_tce_xchg(tbl, entry, &oldhpa, &direction);
+                if (ret)
+                        continue;
+
+                if (direction == DMA_NONE)
                         continue;
 
-                tce_iommu_unuse_page(container, oldtce);
+                tce_iommu_unuse_page(container, oldhpa);
         }
 
         return 0;
@@ -284,12 +284,13 @@ static int tce_iommu_use_page(unsigned long tce, unsigned long *hpa)
 
 static long tce_iommu_build(struct tce_container *container,
                 struct iommu_table *tbl,
-                unsigned long entry, unsigned long tce, unsigned long pages)
+                unsigned long entry, unsigned long tce, unsigned long pages,
+                enum dma_data_direction direction)
 {
         long i, ret = 0;
         struct page *page;
         unsigned long hpa;
-        enum dma_data_direction direction = iommu_tce_direction(tce);
+        enum dma_data_direction dirtmp;
 
         for (i = 0; i < pages; ++i) {
                 unsigned long offset = tce & IOMMU_PAGE_MASK(tbl) & ~PAGE_MASK;
@@ -305,8 +306,8 @@ static long tce_iommu_build(struct tce_container *container,
                 }
 
                 hpa |= offset;
-                ret = iommu_tce_build(tbl, entry + i, (unsigned long) __va(hpa),
-                                direction);
+                dirtmp = direction;
+                ret = iommu_tce_xchg(tbl, entry + i, &hpa, &dirtmp);
                 if (ret) {
                         tce_iommu_unuse_page(container, hpa);
                         pr_err("iommu_tce: %s failed ioba=%lx, tce=%lx, ret=%ld\n",
@@ -314,6 +315,10 @@ static long tce_iommu_build(struct tce_container *container,
                                         tce, ret);
                         break;
                 }
+
+                if (dirtmp != DMA_NONE)
+                        tce_iommu_unuse_page(container, hpa);
+
                 tce += IOMMU_PAGE_SIZE(tbl);
         }
 
@@ -378,8 +383,8 @@ static long tce_iommu_ioctl(void *iommu_data,
         case VFIO_IOMMU_MAP_DMA: {
                 struct vfio_iommu_type1_dma_map param;
                 struct iommu_table *tbl = NULL;
-                unsigned long tce;
                 long num;
+                enum dma_data_direction direction;
 
                 if (!container->enabled)
                         return -EPERM;
@@ -405,19 +410,27 @@ static long tce_iommu_ioctl(void *iommu_data,
                         return -EINVAL;
 
                 /* iova is checked by the IOMMU API */
-                tce = param.vaddr;
-                if (param.flags & VFIO_DMA_MAP_FLAG_READ)
-                        tce |= TCE_PCI_READ;
-                if (param.flags & VFIO_DMA_MAP_FLAG_WRITE)
-                        tce |= TCE_PCI_WRITE;
+                if (param.flags & VFIO_DMA_MAP_FLAG_READ) {
+                        if (param.flags & VFIO_DMA_MAP_FLAG_WRITE)
+                                direction = DMA_BIDIRECTIONAL;
+                        else
+                                direction = DMA_TO_DEVICE;
+                } else {
+                        if (param.flags & VFIO_DMA_MAP_FLAG_WRITE)
+                                direction = DMA_FROM_DEVICE;
+                        else
+                                return -EINVAL;
+                }
 
-                ret = iommu_tce_put_param_check(tbl, param.iova, tce);
+                ret = iommu_tce_put_param_check(tbl, param.iova, param.vaddr);
                 if (ret)
                         return ret;
 
                 ret = tce_iommu_build(container, tbl,
                                 param.iova >> tbl->it_page_shift,
-                                tce, param.size >> tbl->it_page_shift);
+                                param.vaddr,
+                                param.size >> tbl->it_page_shift,
+                                direction);
 
                 iommu_flush_tce(tbl);