Lines Matching full:group
60 ssize_t (*show)(struct iommu_group *group, char *buf);
61 ssize_t (*store)(struct iommu_group *group,
76 static int iommu_alloc_default_domain(struct iommu_group *group,
83 struct iommu_group *group);
85 struct iommu_group *group);
86 static int iommu_create_device_direct_mappings(struct iommu_group *group,
89 static ssize_t iommu_group_store_type(struct iommu_group *group,
218 struct iommu_group *group; in __iommu_probe_device() local
240 group = iommu_group_get_for_dev(dev); in __iommu_probe_device()
241 if (IS_ERR(group)) { in __iommu_probe_device()
242 ret = PTR_ERR(group); in __iommu_probe_device()
245 iommu_group_put(group); in __iommu_probe_device()
247 if (group_list && !group->default_domain && list_empty(&group->entry)) in __iommu_probe_device()
248 list_add_tail(&group->entry, group_list); in __iommu_probe_device()
269 struct iommu_group *group; in iommu_probe_device() local
276 group = iommu_group_get(dev); in iommu_probe_device()
277 if (!group) { in iommu_probe_device()
288 mutex_lock(&group->mutex); in iommu_probe_device()
289 iommu_alloc_default_domain(group, dev); in iommu_probe_device()
290 mutex_unlock(&group->mutex); in iommu_probe_device()
292 if (group->default_domain) { in iommu_probe_device()
293 ret = __iommu_attach_device(group->default_domain, dev); in iommu_probe_device()
295 iommu_group_put(group); in iommu_probe_device()
300 iommu_create_device_direct_mappings(group, dev); in iommu_probe_device()
302 iommu_group_put(group); in iommu_probe_device()
372 struct iommu_group *group = to_iommu_group(kobj); in iommu_group_attr_show() local
376 ret = attr->show(group, buf); in iommu_group_attr_show()
385 struct iommu_group *group = to_iommu_group(kobj); in iommu_group_attr_store() local
389 ret = attr->store(group, buf, count); in iommu_group_attr_store()
398 static int iommu_group_create_file(struct iommu_group *group, in iommu_group_create_file() argument
401 return sysfs_create_file(&group->kobj, &attr->attr); in iommu_group_create_file()
404 static void iommu_group_remove_file(struct iommu_group *group, in iommu_group_remove_file() argument
407 sysfs_remove_file(&group->kobj, &attr->attr); in iommu_group_remove_file()
410 static ssize_t iommu_group_show_name(struct iommu_group *group, char *buf) in iommu_group_show_name() argument
412 return sprintf(buf, "%s\n", group->name); in iommu_group_show_name()
491 int iommu_get_group_resv_regions(struct iommu_group *group, in iommu_get_group_resv_regions() argument
497 mutex_lock(&group->mutex); in iommu_get_group_resv_regions()
498 list_for_each_entry(device, &group->devices, list) { in iommu_get_group_resv_regions()
508 mutex_unlock(&group->mutex); in iommu_get_group_resv_regions()
513 static ssize_t iommu_group_show_resv_regions(struct iommu_group *group, in iommu_group_show_resv_regions() argument
521 iommu_get_group_resv_regions(group, &group_resv_regions); in iommu_group_show_resv_regions()
535 static ssize_t iommu_group_show_type(struct iommu_group *group, in iommu_group_show_type() argument
540 mutex_lock(&group->mutex); in iommu_group_show_type()
541 if (group->default_domain) { in iommu_group_show_type()
542 switch (group->default_domain->type) { in iommu_group_show_type()
560 mutex_unlock(&group->mutex); in iommu_group_show_type()
576 struct iommu_group *group = to_iommu_group(kobj); in iommu_group_release() local
578 pr_debug("Releasing group %d\n", group->id); in iommu_group_release()
580 if (group->iommu_data_release) in iommu_group_release()
581 group->iommu_data_release(group->iommu_data); in iommu_group_release()
583 ida_simple_remove(&iommu_group_ida, group->id); in iommu_group_release()
585 if (group->default_domain) in iommu_group_release()
586 iommu_domain_free(group->default_domain); in iommu_group_release()
588 kfree(group->name); in iommu_group_release()
589 kfree(group); in iommu_group_release()
598 * iommu_group_alloc - Allocate a new group
601 * group. The iommu group represents the minimum granularity of the iommu.
603 * group in order to hold the group until devices are added. Use
605 * group to be automatically reclaimed once it has no devices or external
610 struct iommu_group *group; in iommu_group_alloc() local
613 group = kzalloc(sizeof(*group), GFP_KERNEL); in iommu_group_alloc()
614 if (!group) in iommu_group_alloc()
617 group->kobj.kset = iommu_group_kset; in iommu_group_alloc()
618 mutex_init(&group->mutex); in iommu_group_alloc()
619 INIT_LIST_HEAD(&group->devices); in iommu_group_alloc()
620 INIT_LIST_HEAD(&group->entry); in iommu_group_alloc()
621 BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier); in iommu_group_alloc()
625 kfree(group); in iommu_group_alloc()
628 group->id = ret; in iommu_group_alloc()
630 ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype, in iommu_group_alloc()
631 NULL, "%d", group->id); in iommu_group_alloc()
633 ida_simple_remove(&iommu_group_ida, group->id); in iommu_group_alloc()
634 kobject_put(&group->kobj); in iommu_group_alloc()
638 group->devices_kobj = kobject_create_and_add("devices", &group->kobj); in iommu_group_alloc()
639 if (!group->devices_kobj) { in iommu_group_alloc()
640 kobject_put(&group->kobj); /* triggers .release & free */ in iommu_group_alloc()
645 * The devices_kobj holds a reference on the group kobject, so in iommu_group_alloc()
646 * as long as that exists so will the group. We can therefore in iommu_group_alloc()
649 kobject_put(&group->kobj); in iommu_group_alloc()
651 ret = iommu_group_create_file(group, in iommu_group_alloc()
656 ret = iommu_group_create_file(group, &iommu_group_attr_type); in iommu_group_alloc()
660 pr_debug("Allocated group %d\n", group->id); in iommu_group_alloc()
662 return group; in iommu_group_alloc()
669 struct iommu_group *group; in iommu_group_get_by_id() local
685 group = container_of(group_kobj, struct iommu_group, kobj); in iommu_group_get_by_id()
686 BUG_ON(group->id != id); in iommu_group_get_by_id()
688 kobject_get(group->devices_kobj); in iommu_group_get_by_id()
689 kobject_put(&group->kobj); in iommu_group_get_by_id()
691 return group; in iommu_group_get_by_id()
696 * iommu_group_get_iommudata - retrieve iommu_data registered for a group
697 * @group: the group
699 * iommu drivers can store data in the group for use when doing iommu
701 * should hold a group reference.
703 void *iommu_group_get_iommudata(struct iommu_group *group) in iommu_group_get_iommudata() argument
705 return group->iommu_data; in iommu_group_get_iommudata()
710 * iommu_group_set_iommudata - set iommu_data for a group
711 * @group: the group
715 * iommu drivers can store data in the group for use when doing iommu
717 * the group has been allocated. Caller should hold a group reference.
719 void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data, in iommu_group_set_iommudata() argument
722 group->iommu_data = iommu_data; in iommu_group_set_iommudata()
723 group->iommu_data_release = release; in iommu_group_set_iommudata()
728 * iommu_group_set_name - set name for a group
729 * @group: the group
732 * Allow iommu driver to set a name for a group. When set it will
733 * appear in a name attribute file under the group in sysfs.
735 int iommu_group_set_name(struct iommu_group *group, const char *name) in iommu_group_set_name() argument
739 if (group->name) { in iommu_group_set_name()
740 iommu_group_remove_file(group, &iommu_group_attr_name); in iommu_group_set_name()
741 kfree(group->name); in iommu_group_set_name()
742 group->name = NULL; in iommu_group_set_name()
747 group->name = kstrdup(name, GFP_KERNEL); in iommu_group_set_name()
748 if (!group->name) in iommu_group_set_name()
751 ret = iommu_group_create_file(group, &iommu_group_attr_name); in iommu_group_set_name()
753 kfree(group->name); in iommu_group_set_name()
754 group->name = NULL; in iommu_group_set_name()
762 static int iommu_create_device_direct_mappings(struct iommu_group *group, in iommu_create_device_direct_mappings() argument
765 struct iommu_domain *domain = group->default_domain; in iommu_create_device_direct_mappings()
839 * iommu_group_add_device - add a device to an iommu group
840 * @group: the group into which to add the device (reference should be held)
844 * group. Adding a device increments the group reference count.
846 int iommu_group_add_device(struct iommu_group *group, struct device *dev) in iommu_group_add_device() argument
857 ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group"); in iommu_group_add_device()
868 ret = sysfs_create_link_nowarn(group->devices_kobj, in iommu_group_add_device()
884 kobject_get(group->devices_kobj); in iommu_group_add_device()
886 dev->iommu_group = group; in iommu_group_add_device()
888 mutex_lock(&group->mutex); in iommu_group_add_device()
889 list_add_tail(&device->list, &group->devices); in iommu_group_add_device()
890 if (group->domain && !iommu_is_attach_deferred(group->domain, dev)) in iommu_group_add_device()
891 ret = __iommu_attach_device(group->domain, dev); in iommu_group_add_device()
892 mutex_unlock(&group->mutex); in iommu_group_add_device()
896 /* Notify any listeners about change to group. */ in iommu_group_add_device()
897 blocking_notifier_call_chain(&group->notifier, in iommu_group_add_device()
900 trace_add_device_to_group(group->id, dev); in iommu_group_add_device()
902 dev_info(dev, "Adding to iommu group %d\n", group->id); in iommu_group_add_device()
907 mutex_lock(&group->mutex); in iommu_group_add_device()
909 mutex_unlock(&group->mutex); in iommu_group_add_device()
911 kobject_put(group->devices_kobj); in iommu_group_add_device()
912 sysfs_remove_link(group->devices_kobj, device->name); in iommu_group_add_device()
919 dev_err(dev, "Failed to add to iommu group %d: %d\n", group->id, ret); in iommu_group_add_device()
925 * iommu_group_remove_device - remove a device from it's current group
929 * it's current group. This decrements the iommu group reference count.
933 struct iommu_group *group = dev->iommu_group; in iommu_group_remove_device() local
936 if (!group) in iommu_group_remove_device()
939 dev_info(dev, "Removing from iommu group %d\n", group->id); in iommu_group_remove_device()
942 blocking_notifier_call_chain(&group->notifier, in iommu_group_remove_device()
945 mutex_lock(&group->mutex); in iommu_group_remove_device()
946 list_for_each_entry(tmp_device, &group->devices, list) { in iommu_group_remove_device()
953 mutex_unlock(&group->mutex); in iommu_group_remove_device()
958 sysfs_remove_link(group->devices_kobj, device->name); in iommu_group_remove_device()
961 trace_remove_device_from_group(group->id, dev); in iommu_group_remove_device()
966 kobject_put(group->devices_kobj); in iommu_group_remove_device()
970 static int iommu_group_device_count(struct iommu_group *group) in iommu_group_device_count() argument
975 list_for_each_entry(entry, &group->devices, list) in iommu_group_device_count()
982 * iommu_group_for_each_dev - iterate over each device in the group
983 * @group: the group
987 * This function is called by group users to iterate over group devices.
988 * Callers should hold a reference count to the group during callback.
989 * The group->mutex is held across callbacks, which will block calls to
992 static int __iommu_group_for_each_dev(struct iommu_group *group, void *data, in __iommu_group_for_each_dev() argument
998 list_for_each_entry(device, &group->devices, list) { in __iommu_group_for_each_dev()
1007 int iommu_group_for_each_dev(struct iommu_group *group, void *data, in iommu_group_for_each_dev() argument
1012 mutex_lock(&group->mutex); in iommu_group_for_each_dev()
1013 ret = __iommu_group_for_each_dev(group, data, fn); in iommu_group_for_each_dev()
1014 mutex_unlock(&group->mutex); in iommu_group_for_each_dev()
1021 * iommu_group_get - Return the group for a device and increment reference
1022 * @dev: get the group that this device belongs to
1024 * This function is called by iommu drivers and users to get the group
1025 * for the specified device. If found, the group is returned and the group
1030 struct iommu_group *group = dev->iommu_group; in iommu_group_get() local
1032 if (group) in iommu_group_get()
1033 kobject_get(group->devices_kobj); in iommu_group_get()
1035 return group; in iommu_group_get()
1040 * iommu_group_ref_get - Increment reference on a group
1041 * @group: the group to use, must not be NULL
1044 * existing group. Returns the given group for convenience.
1046 struct iommu_group *iommu_group_ref_get(struct iommu_group *group) in iommu_group_ref_get() argument
1048 kobject_get(group->devices_kobj); in iommu_group_ref_get()
1049 return group; in iommu_group_ref_get()
1054 * iommu_group_put - Decrement group reference
1055 * @group: the group to use
1058 * iommu group. Once the reference count is zero, the group is released.
1060 void iommu_group_put(struct iommu_group *group) in iommu_group_put() argument
1062 if (group) in iommu_group_put()
1063 kobject_put(group->devices_kobj); in iommu_group_put()
1068 * iommu_group_register_notifier - Register a notifier for group changes
1069 * @group: the group to watch
1072 * This function allows iommu group users to track changes in a group.
1074 * should hold a reference to the group throughout notifier registration.
1076 int iommu_group_register_notifier(struct iommu_group *group, in iommu_group_register_notifier() argument
1079 return blocking_notifier_chain_register(&group->notifier, nb); in iommu_group_register_notifier()
1085 * @group: the group to watch
1088 * Unregister a previously registered group notifier block.
1090 int iommu_group_unregister_notifier(struct iommu_group *group, in iommu_group_unregister_notifier() argument
1093 return blocking_notifier_chain_unregister(&group->notifier, nb); in iommu_group_unregister_notifier()
1282 * matched using the group ID, the PASID valid bit and the PASID in iommu_page_response()
1283 * value. Otherwise only the group ID matches request and in iommu_page_response()
1309 * iommu_group_id - Return ID for a group
1310 * @group: the group to ID
1312 * Return the unique ID for the group matching the sysfs group number.
1314 int iommu_group_id(struct iommu_group *group) in iommu_group_id() argument
1316 return group->id; in iommu_group_id()
1337 * that may already have a group.
1343 struct iommu_group *group; in get_pci_function_alias_group() local
1354 group = get_pci_alias_group(tmp, devfns); in get_pci_function_alias_group()
1355 if (group) { in get_pci_function_alias_group()
1357 return group; in get_pci_function_alias_group()
1377 struct iommu_group *group; in get_pci_alias_group() local
1382 group = iommu_group_get(&pdev->dev); in get_pci_alias_group()
1383 if (group) in get_pci_alias_group()
1384 return group; in get_pci_alias_group()
1392 group = get_pci_alias_group(tmp, devfns); in get_pci_alias_group()
1393 if (group) { in get_pci_alias_group()
1395 return group; in get_pci_alias_group()
1398 group = get_pci_function_alias_group(tmp, devfns); in get_pci_alias_group()
1399 if (group) { in get_pci_alias_group()
1401 return group; in get_pci_alias_group()
1411 struct iommu_group *group; member
1416 * the IOMMU group if we find one along the way.
1423 data->group = iommu_group_get(&pdev->dev); in get_pci_alias_or_group()
1425 return data->group != NULL; in get_pci_alias_or_group()
1430 * iommu-group per device.
1440 * to find or create an IOMMU group for a device.
1447 struct iommu_group *group = NULL; in pci_device_group() local
1455 * be aliased due to topology in order to have its own IOMMU group. in pci_device_group()
1457 * group, use it. in pci_device_group()
1460 return data.group; in pci_device_group()
1468 * group, use it. in pci_device_group()
1479 group = iommu_group_get(&pdev->dev); in pci_device_group()
1480 if (group) in pci_device_group()
1481 return group; in pci_device_group()
1486 * device or another device aliases us, use the same group. in pci_device_group()
1488 group = get_pci_alias_group(pdev, (unsigned long *)devfns); in pci_device_group()
1489 if (group) in pci_device_group()
1490 return group; in pci_device_group()
1497 group = get_pci_function_alias_group(pdev, (unsigned long *)devfns); in pci_device_group()
1498 if (group) in pci_device_group()
1499 return group; in pci_device_group()
1501 /* No shared group found, allocate new */ in pci_device_group()
1506 /* Get the IOMMU group for device on fsl-mc bus */
1510 struct iommu_group *group; in fsl_mc_device_group() local
1512 group = iommu_group_get(cont_dev); in fsl_mc_device_group()
1513 if (!group) in fsl_mc_device_group()
1514 group = iommu_group_alloc(); in fsl_mc_device_group()
1515 return group; in fsl_mc_device_group()
1533 struct iommu_group *group, in iommu_group_alloc_default_domain() argument
1542 …pr_warn("Failed to allocate default IOMMU domain of type %u for group %s - Falling back to IOMMU_D… in iommu_group_alloc_default_domain()
1543 type, group->name); in iommu_group_alloc_default_domain()
1549 group->default_domain = dom; in iommu_group_alloc_default_domain()
1550 if (!group->domain) in iommu_group_alloc_default_domain()
1551 group->domain = dom; in iommu_group_alloc_default_domain()
1555 static int iommu_alloc_default_domain(struct iommu_group *group, in iommu_alloc_default_domain() argument
1560 if (group->default_domain) in iommu_alloc_default_domain()
1565 return iommu_group_alloc_default_domain(dev->bus, group, type); in iommu_alloc_default_domain()
1569 * iommu_group_get_for_dev - Find or create the IOMMU group for a device
1574 * IOMMU group for a device. On success, the caller will hold a reference
1575 * to the returned IOMMU group, which will already include the provided
1581 struct iommu_group *group; in iommu_group_get_for_dev() local
1584 group = iommu_group_get(dev); in iommu_group_get_for_dev()
1585 if (group) in iommu_group_get_for_dev()
1586 return group; in iommu_group_get_for_dev()
1591 group = ops->device_group(dev); in iommu_group_get_for_dev()
1592 if (WARN_ON_ONCE(group == NULL)) in iommu_group_get_for_dev()
1595 if (IS_ERR(group)) in iommu_group_get_for_dev()
1596 return group; in iommu_group_get_for_dev()
1598 ret = iommu_group_add_device(group, dev); in iommu_group_get_for_dev()
1602 return group; in iommu_group_get_for_dev()
1605 iommu_group_put(group); in iommu_group_get_for_dev()
1610 struct iommu_domain *iommu_group_default_domain(struct iommu_group *group) in iommu_group_default_domain() argument
1612 return group->default_domain; in iommu_group_default_domain()
1618 struct iommu_group *group; in probe_iommu_group() local
1621 /* Device is probed already if in a group */ in probe_iommu_group()
1622 group = iommu_group_get(dev); in probe_iommu_group()
1623 if (group) { in probe_iommu_group()
1624 iommu_group_put(group); in probe_iommu_group()
1647 struct iommu_group *group; in iommu_bus_notifier() local
1651 * result in ADD/DEL notifiers to group->notifier in iommu_bus_notifier()
1665 * group, if anyone is listening in iommu_bus_notifier()
1667 group = iommu_group_get(dev); in iommu_bus_notifier()
1668 if (!group) in iommu_bus_notifier()
1687 blocking_notifier_call_chain(&group->notifier, in iommu_bus_notifier()
1690 iommu_group_put(group); in iommu_bus_notifier()
1706 …dev_warn(dev, "Device needs domain type %s, but device %s in the same iommu group requires type %s… in probe_get_default_domain_type()
1723 struct iommu_group *group) in probe_alloc_default_domain() argument
1729 /* Ask for default domain requirements of all devices in the group */ in probe_alloc_default_domain()
1730 __iommu_group_for_each_dev(group, >ype, in probe_alloc_default_domain()
1736 iommu_group_alloc_default_domain(bus, group, gtype.type); in probe_alloc_default_domain()
1751 static int __iommu_group_dma_attach(struct iommu_group *group) in __iommu_group_dma_attach() argument
1753 return __iommu_group_for_each_dev(group, group->default_domain, in __iommu_group_dma_attach()
1767 static void __iommu_group_dma_finalize(struct iommu_group *group) in __iommu_group_dma_finalize() argument
1769 __iommu_group_for_each_dev(group, group->default_domain, in __iommu_group_dma_finalize()
1775 struct iommu_group *group = data; in iommu_do_create_direct_mappings() local
1777 iommu_create_device_direct_mappings(group, dev); in iommu_do_create_direct_mappings()
1782 static int iommu_group_create_direct_mappings(struct iommu_group *group) in iommu_group_create_direct_mappings() argument
1784 return __iommu_group_for_each_dev(group, group, in iommu_group_create_direct_mappings()
1790 struct iommu_group *group, *next; in bus_iommu_probe() local
1796 * creating the iommu group, so do it after the groups are in bus_iommu_probe()
1803 list_for_each_entry_safe(group, next, &group_list, entry) { in bus_iommu_probe()
1805 list_del_init(&group->entry); in bus_iommu_probe()
1807 mutex_lock(&group->mutex); in bus_iommu_probe()
1810 probe_alloc_default_domain(bus, group); in bus_iommu_probe()
1812 if (!group->default_domain) { in bus_iommu_probe()
1813 mutex_unlock(&group->mutex); in bus_iommu_probe()
1817 iommu_group_create_direct_mappings(group); in bus_iommu_probe()
1819 ret = __iommu_group_dma_attach(group); in bus_iommu_probe()
1821 mutex_unlock(&group->mutex); in bus_iommu_probe()
1826 __iommu_group_dma_finalize(group); in bus_iommu_probe()
1993 struct iommu_group *group; in iommu_attach_device() local
1996 group = iommu_group_get(dev); in iommu_attach_device()
1997 if (!group) in iommu_attach_device()
2001 * Lock the group to make sure the device-count doesn't in iommu_attach_device()
2004 mutex_lock(&group->mutex); in iommu_attach_device()
2006 if (iommu_group_device_count(group) != 1) in iommu_attach_device()
2009 ret = __iommu_attach_group(domain, group); in iommu_attach_device()
2012 mutex_unlock(&group->mutex); in iommu_attach_device()
2013 iommu_group_put(group); in iommu_attach_device()
2254 struct iommu_group *group; in iommu_detach_device() local
2256 group = iommu_group_get(dev); in iommu_detach_device()
2257 if (!group) in iommu_detach_device()
2260 mutex_lock(&group->mutex); in iommu_detach_device()
2261 if (iommu_group_device_count(group) != 1) { in iommu_detach_device()
2266 __iommu_detach_group(domain, group); in iommu_detach_device()
2269 mutex_unlock(&group->mutex); in iommu_detach_device()
2270 iommu_group_put(group); in iommu_detach_device()
2277 struct iommu_group *group; in iommu_get_domain_for_dev() local
2279 group = iommu_group_get(dev); in iommu_get_domain_for_dev()
2280 if (!group) in iommu_get_domain_for_dev()
2283 domain = group->domain; in iommu_get_domain_for_dev()
2285 iommu_group_put(group); in iommu_get_domain_for_dev()
2293 * guarantees that the group and its default domain are valid and correct.
2303 * iterating over the devices in a group. Ideally we'd have a single
2304 * device which represents the requestor ID of the group, but we also
2307 * wish to group them at a higher level (ex. untrusted multi-function
2318 struct iommu_group *group) in __iommu_attach_group() argument
2322 if (group->default_domain && group->domain != group->default_domain) in __iommu_attach_group()
2325 ret = __iommu_group_for_each_dev(group, domain, in __iommu_attach_group()
2328 group->domain = domain; in __iommu_attach_group()
2333 int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group) in iommu_attach_group() argument
2337 mutex_lock(&group->mutex); in iommu_attach_group()
2338 ret = __iommu_attach_group(domain, group); in iommu_attach_group()
2339 mutex_unlock(&group->mutex); in iommu_attach_group()
2355 struct iommu_group *group) in __iommu_detach_group() argument
2359 if (!group->default_domain) { in __iommu_detach_group()
2360 __iommu_group_for_each_dev(group, domain, in __iommu_detach_group()
2362 group->domain = NULL; in __iommu_detach_group()
2366 if (group->domain == group->default_domain) in __iommu_detach_group()
2370 ret = __iommu_group_for_each_dev(group, group->default_domain, in __iommu_detach_group()
2375 group->domain = group->default_domain; in __iommu_detach_group()
2378 void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group) in iommu_detach_group() argument
2380 mutex_lock(&group->mutex); in iommu_detach_group()
2381 __iommu_detach_group(domain, group); in iommu_detach_group()
2382 mutex_unlock(&group->mutex); in iommu_detach_group()
3048 struct iommu_group *group; in iommu_sva_bind_device() local
3055 group = iommu_group_get(dev); in iommu_sva_bind_device()
3056 if (!group) in iommu_sva_bind_device()
3060 mutex_lock(&group->mutex); in iommu_sva_bind_device()
3068 if (iommu_group_device_count(group) != 1) in iommu_sva_bind_device()
3074 mutex_unlock(&group->mutex); in iommu_sva_bind_device()
3075 iommu_group_put(group); in iommu_sva_bind_device()
3091 struct iommu_group *group; in iommu_sva_unbind_device() local
3098 group = iommu_group_get(dev); in iommu_sva_unbind_device()
3099 if (!group) in iommu_sva_unbind_device()
3102 mutex_lock(&group->mutex); in iommu_sva_unbind_device()
3104 mutex_unlock(&group->mutex); in iommu_sva_unbind_device()
3106 iommu_group_put(group); in iommu_sva_unbind_device()
3122 * Changes the default domain of an iommu group that has *only* one device
3124 * @group: The group for which the default domain should be changed
3125 * @prev_dev: The device in the group (this is used to make sure that the device
3127 * @type: The type of the new default domain that gets associated with the group
3133 * group's default domain type through /sys/kernel/iommu_groups/<grp_id>/type
3136 static int iommu_change_dev_def_domain(struct iommu_group *group, in iommu_change_dev_def_domain() argument
3144 mutex_lock(&group->mutex); in iommu_change_dev_def_domain()
3146 if (group->default_domain != group->domain) { in iommu_change_dev_def_domain()
3147 dev_err_ratelimited(prev_dev, "Group not assigned to default domain\n"); in iommu_change_dev_def_domain()
3153 * iommu group wasn't locked while acquiring device lock in in iommu_change_dev_def_domain()
3157 * Changing default domain of an iommu group with two or more devices in iommu_change_dev_def_domain()
3160 * the devices in the group and before it could acquire all of them, in iommu_change_dev_def_domain()
3165 if (iommu_group_device_count(group) != 1) { in iommu_change_dev_def_domain()
3166 dev_err_ratelimited(prev_dev, "Cannot change default domain: Group has more than one device\n"); in iommu_change_dev_def_domain()
3171 /* Since group has only one device */ in iommu_change_dev_def_domain()
3172 grp_dev = list_first_entry(&group->devices, struct group_device, list); in iommu_change_dev_def_domain()
3181 prev_dom = group->default_domain; in iommu_change_dev_def_domain()
3219 /* Sets group->default_domain to the newly allocated domain */ in iommu_change_dev_def_domain()
3220 ret = iommu_group_alloc_default_domain(dev->bus, group, type); in iommu_change_dev_def_domain()
3224 ret = iommu_create_device_direct_mappings(group, dev); in iommu_change_dev_def_domain()
3228 ret = __iommu_attach_device(group->default_domain, dev); in iommu_change_dev_def_domain()
3232 group->domain = group->default_domain; in iommu_change_dev_def_domain()
3238 * group->mutex, resulting in a deadlock. in iommu_change_dev_def_domain()
3240 mutex_unlock(&group->mutex); in iommu_change_dev_def_domain()
3243 iommu_group_do_probe_finalize(dev, group->default_domain); in iommu_change_dev_def_domain()
3248 iommu_domain_free(group->default_domain); in iommu_change_dev_def_domain()
3249 group->default_domain = prev_dom; in iommu_change_dev_def_domain()
3250 group->domain = prev_dom; in iommu_change_dev_def_domain()
3253 mutex_unlock(&group->mutex); in iommu_change_dev_def_domain()
3260 * drivers from the devices in the iommu group, except for a DMA -> DMA-FQ
3267 static ssize_t iommu_group_store_type(struct iommu_group *group, in iommu_group_store_type() argument
3277 if (WARN_ON(!group)) in iommu_group_store_type()
3292 * Lock/Unlock the group mutex here before device lock to in iommu_group_store_type()
3293 * 1. Make sure that the iommu group has only one device (this is a in iommu_group_store_type()
3297 mutex_lock(&group->mutex); in iommu_group_store_type()
3298 if (iommu_group_device_count(group) != 1) { in iommu_group_store_type()
3299 mutex_unlock(&group->mutex); in iommu_group_store_type()
3300 pr_err_ratelimited("Cannot change default domain: Group has more than one device\n"); in iommu_group_store_type()
3304 /* Since group has only one device */ in iommu_group_store_type()
3305 grp_dev = list_first_entry(&group->devices, struct group_device, list); in iommu_group_store_type()
3310 * Don't hold the group mutex because taking group mutex first and then in iommu_group_store_type()
3313 * iommu group and T2 is trying to hot unplug a device or release [1] VF in iommu_group_store_type()
3314 * of a PCIe device which is in the same iommu group. T1 takes group in iommu_group_store_type()
3316 * lock and is yet to take group mutex. Now, both the threads will be in iommu_group_store_type()
3320 * mutex_lock(&group->mutex); in iommu_group_store_type()
3322 * mutex_unlock(&group->mutex); in iommu_group_store_type()
3333 mutex_unlock(&group->mutex); in iommu_group_store_type()
3335 /* Check if the device in the group still has a driver bound to it */ in iommu_group_store_type()
3338 group->default_domain->type == IOMMU_DOMAIN_DMA)) { in iommu_group_store_type()
3344 ret = iommu_change_dev_def_domain(group, dev, req_type); in iommu_group_store_type()