iommu: Split off default domain allocation from group assignment

When a bus is initialized with iommu-ops, all devices on the bus are
scanned and iommu-groups are allocated for them, and each groups will
also get a default domain allocated.

Until now this happened as soon as the group was created and the first
device added to it. When other devices with different default domain
requirements were added to the group later on, the default domain was
re-allocated, if possible.

This resulted in some back and forth and unnecessary allocations, so
change the flow to defer default domain allocation until all devices
have been added to their respective IOMMU groups.

The default domains are allocated for newly allocated groups after
each device on the bus is handled and was probed by the IOMMU driver.

Signed-off-by: Joerg Roedel <jroedel@suse.de>
Tested-by: Marek Szyprowski <m.szyprowski@samsung.com>
Acked-by: Marek Szyprowski <m.szyprowski@samsung.com>
Link: https://lore.kernel.org/r/20200429133712.31431-12-joro@8bytes.org
Signed-off-by: Joerg Roedel <jroedel@suse.de>

diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
index 8be047a4808f7b3dc2021d5a3c08e45803696ed7..7de0e29db3338426e6c2fe75d7ed8daa80055341 100644 (file)
--- a/drivers/iommu/iommu.c
+++ b/drivers/iommu/iommu.c
@@ -199,7 +199,7 @@ static int __iommu_probe_device(struct device *dev, struct list_head *group_list
        dev->iommu->iommu_dev = iommu_dev;
 
        group = iommu_group_get_for_dev(dev);
-       if (!IS_ERR(group)) {
+       if (IS_ERR(group)) {
                ret = PTR_ERR(group);
                goto out_release;
        }
@@ -1599,6 +1599,37 @@ static int add_iommu_group(struct device *dev, void *data)
        return ret;
 }
 
+static int probe_iommu_group(struct device *dev, void *data)
+{
+       const struct iommu_ops *ops = dev->bus->iommu_ops;
+       struct list_head *group_list = data;
+       int ret;
+
+       if (!dev_iommu_get(dev))
+               return -ENOMEM;
+
+       if (!try_module_get(ops->owner)) {
+               ret = -EINVAL;
+               goto err_free_dev_iommu;
+       }
+
+       ret = __iommu_probe_device(dev, group_list);
+       if (ret)
+               goto err_module_put;
+
+       return 0;
+
+err_module_put:
+       module_put(ops->owner);
+err_free_dev_iommu:
+       dev_iommu_free(dev);
+
+       if (ret == -ENODEV)
+               ret = 0;
+
+       return ret;
+}
+
 static int remove_iommu_group(struct device *dev, void *data)
 {
        iommu_release_device(dev);
@@ -1658,10 +1689,127 @@ static int iommu_bus_notifier(struct notifier_block *nb,
        return 0;
 }
 
+struct __group_domain_type {
+       struct device *dev;
+       unsigned int type;
+};
+
+static int probe_get_default_domain_type(struct device *dev, void *data)
+{
+       const struct iommu_ops *ops = dev->bus->iommu_ops;
+       struct __group_domain_type *gtype = data;
+       unsigned int type = 0;
+
+       if (ops->def_domain_type)
+               type = ops->def_domain_type(dev);
+
+       if (type) {
+               if (gtype->type && gtype->type != type) {
+                       dev_warn(dev, "Device needs domain type %s, but device %s in the same iommu group requires type %s - using default\n",
+                                iommu_domain_type_str(type),
+                                dev_name(gtype->dev),
+                                iommu_domain_type_str(gtype->type));
+                       gtype->type = 0;
+               }
+
+               if (!gtype->dev) {
+                       gtype->dev  = dev;
+                       gtype->type = type;
+               }
+       }
+
+       return 0;
+}
+
+static void probe_alloc_default_domain(struct bus_type *bus,
+                                      struct iommu_group *group)
+{
+       struct __group_domain_type gtype;
+
+       memset(&gtype, 0, sizeof(gtype));
+
+       /* Ask for default domain requirements of all devices in the group */
+       __iommu_group_for_each_dev(group, &gtype,
+                                  probe_get_default_domain_type);
+
+       if (!gtype.type)
+               gtype.type = iommu_def_domain_type;
+
+       iommu_group_alloc_default_domain(bus, group, gtype.type);
+}
+
+static int iommu_group_do_dma_attach(struct device *dev, void *data)
+{
+       struct iommu_domain *domain = data;
+       const struct iommu_ops *ops;
+       int ret;
+
+       ret = __iommu_attach_device(domain, dev);
+
+       ops = domain->ops;
+
+       if (ret == 0 && ops->probe_finalize)
+               ops->probe_finalize(dev);
+
+       return ret;
+}
+
+static int __iommu_group_dma_attach(struct iommu_group *group)
+{
+       return __iommu_group_for_each_dev(group, group->default_domain,
+                                         iommu_group_do_dma_attach);
+}
+
+static int bus_iommu_probe(struct bus_type *bus)
+{
+       const struct iommu_ops *ops = bus->iommu_ops;
+       int ret;
+
+       if (ops->probe_device) {
+               struct iommu_group *group, *next;
+               LIST_HEAD(group_list);
+
+               /*
+                * This code-path does not allocate the default domain when
+                * creating the iommu group, so do it after the groups are
+                * created.
+                */
+               ret = bus_for_each_dev(bus, NULL, &group_list, probe_iommu_group);
+               if (ret)
+                       return ret;
+
+               list_for_each_entry_safe(group, next, &group_list, entry) {
+                       /* Remove item from the list */
+                       list_del_init(&group->entry);
+
+                       mutex_lock(&group->mutex);
+
+                       /* Try to allocate default domain */
+                       probe_alloc_default_domain(bus, group);
+
+                       if (!group->default_domain) {
+                               mutex_unlock(&group->mutex);
+                               continue;
+                       }
+
+                       ret = __iommu_group_dma_attach(group);
+
+                       mutex_unlock(&group->mutex);
+
+                       if (ret)
+                               break;
+               }
+       } else {
+               ret = bus_for_each_dev(bus, NULL, NULL, add_iommu_group);
+       }
+
+       return ret;
+}
+
 static int iommu_bus_init(struct bus_type *bus, const struct iommu_ops *ops)
 {
-       int err;
        struct notifier_block *nb;
+       int err;
 
        nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
        if (!nb)
@@ -1673,7 +1821,7 @@ static int iommu_bus_init(struct bus_type *bus, const struct iommu_ops *ops)
        if (err)
                goto out_free;
 
-       err = bus_for_each_dev(bus, NULL, NULL, add_iommu_group);
+       err = bus_iommu_probe(bus);
        if (err)
                goto out_err;