vfio: powerpc/spapr: powerpc/powernv/ioda2: Use DMA windows API in ownership control

Before the IOMMU user (VFIO) would take control over the IOMMU table
belonging to a specific IOMMU group. This approach did not allow sharing
tables between IOMMU groups attached to the same container.

This introduces a new IOMMU ownership flavour when the user can not
just control the existing IOMMU table but remove/create tables on demand.
If an IOMMU implements take/release_ownership() callbacks, this lets
the user have full control over the IOMMU group. When the ownership
is taken, the platform code removes all the windows so the caller must
create them.
Before returning the ownership back to the platform code, VFIO
unprograms and removes all the tables it created.

This changes IODA2's onwership handler to remove the existing table
rather than manipulating with the existing one. From now on,
iommu_take_ownership() and iommu_release_ownership() are only called
from the vfio_iommu_spapr_tce driver.

Old-style ownership is still supported allowing VFIO to run on older
P5IOC2 and IODA IO controllers.

No change in userspace-visible behaviour is expected. Since it recreates
TCE tables on each ownership change, related kernel traces will appear
more often.

This adds a pnv_pci_ioda2_setup_default_config() which is called
when PE is being configured at boot time and when the ownership is
passed from VFIO to the platform code.

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, 87 insertions, 1 deletions

diff --git a/drivers/vfio/vfio_iommu_spapr_tce.c b/drivers/vfio/vfio_iommu_spapr_tce.c
index 6d919eb4251f..203caacf2242 100644
--- a/drivers/vfio/vfio_iommu_spapr_tce.c
+++ b/drivers/vfio/vfio_iommu_spapr_tce.c
@@ -333,6 +333,45 @@ static long tce_iommu_build(struct tce_container *container,
         return ret;
 }
 
+static long tce_iommu_create_table(struct tce_container *container,
+                        struct iommu_table_group *table_group,
+                        int num,
+                        __u32 page_shift,
+                        __u64 window_size,
+                        __u32 levels,
+                        struct iommu_table **ptbl)
+{
+        long ret, table_size;
+
+        table_size = table_group->ops->get_table_size(page_shift, window_size,
+                        levels);
+        if (!table_size)
+                return -EINVAL;
+
+        ret = try_increment_locked_vm(table_size >> PAGE_SHIFT);
+        if (ret)
+                return ret;
+
+        ret = table_group->ops->create_table(table_group, num,
+                        page_shift, window_size, levels, ptbl);
+
+        WARN_ON(!ret && !(*ptbl)->it_ops->free);
+        WARN_ON(!ret && ((*ptbl)->it_allocated_size != table_size));
+
+        if (ret)
+                decrement_locked_vm(table_size >> PAGE_SHIFT);
+
+        return ret;
+}
+
+static void tce_iommu_free_table(struct iommu_table *tbl)
+{
+        unsigned long pages = tbl->it_allocated_size >> PAGE_SHIFT;
+
+        tbl->it_ops->free(tbl);
+        decrement_locked_vm(pages);
+}
+
 static long tce_iommu_ioctl(void *iommu_data,
                                  unsigned int cmd, unsigned long arg)
 {
@@ -546,15 +585,62 @@ static int tce_iommu_take_ownership(struct tce_container *container,
 static void tce_iommu_release_ownership_ddw(struct tce_container *container,
                 struct iommu_table_group *table_group)
 {
+        long i;
+
+        if (!table_group->ops->unset_window) {
+                WARN_ON_ONCE(1);
+                return;
+        }
+
+        for (i = 0; i < IOMMU_TABLE_GROUP_MAX_TABLES; ++i) {
+                /* Store table pointer as unset_window resets it */
+                struct iommu_table *tbl = table_group->tables[i];
+
+                if (!tbl)
+                        continue;
+
+                table_group->ops->unset_window(table_group, i);
+                tce_iommu_clear(container, tbl,
+                                tbl->it_offset, tbl->it_size);
+                tce_iommu_free_table(tbl);
+        }
+
         table_group->ops->release_ownership(table_group);
 }
 
 static long tce_iommu_take_ownership_ddw(struct tce_container *container,
                 struct iommu_table_group *table_group)
 {
+        long ret;
+        struct iommu_table *tbl = NULL;
+
+        if (!table_group->ops->create_table || !table_group->ops->set_window ||
+                        !table_group->ops->release_ownership) {
+                WARN_ON_ONCE(1);
+                return -EFAULT;
+        }
+
         table_group->ops->take_ownership(table_group);
 
-        return 0;
+        ret = tce_iommu_create_table(container,
+                        table_group,
+                        0, /* window number */
+                        IOMMU_PAGE_SHIFT_4K,
+                        table_group->tce32_size,
+                        1, /* default levels */
+                        &tbl);
+        if (!ret) {
+                ret = table_group->ops->set_window(table_group, 0, tbl);
+                if (ret)
+                        tce_iommu_free_table(tbl);
+                else
+                        table_group->tables[0] = tbl;
+        }
+
+        if (ret)
+                table_group->ops->release_ownership(table_group);
+
+        return ret;
 }
 
 static int tce_iommu_attach_group(void *iommu_data,