Lines Matching refs:group
58 ssize_t (*show)(struct iommu_group *group, char *buf);
59 ssize_t (*store)(struct iommu_group *group,
83 static int iommu_alloc_default_domain(struct iommu_group *group,
90 struct iommu_group *group);
92 struct iommu_group *group);
93 static int iommu_create_device_direct_mappings(struct iommu_group *group,
202 struct iommu_group *group;
224 group = iommu_group_get_for_dev(dev);
225 if (IS_ERR(group)) {
226 ret = PTR_ERR(group);
229 iommu_group_put(group);
231 if (group_list && !group->default_domain && list_empty(&group->entry))
232 list_add_tail(&group->entry, group_list);
253 struct iommu_group *group;
260 group = iommu_group_get(dev);
261 if (!group)
270 iommu_alloc_default_domain(group, dev);
272 if (group->default_domain) {
273 ret = __iommu_attach_device(group->default_domain, dev);
275 iommu_group_put(group);
280 iommu_create_device_direct_mappings(group, dev);
282 iommu_group_put(group);
341 struct iommu_group *group = to_iommu_group(kobj);
345 ret = attr->show(group, buf);
354 struct iommu_group *group = to_iommu_group(kobj);
358 ret = attr->store(group, buf, count);
367 static int iommu_group_create_file(struct iommu_group *group,
370 return sysfs_create_file(&group->kobj, &attr->attr);
373 static void iommu_group_remove_file(struct iommu_group *group,
376 sysfs_remove_file(&group->kobj, &attr->attr);
379 static ssize_t iommu_group_show_name(struct iommu_group *group, char *buf)
381 return sprintf(buf, "%s\n", group->name);
460 int iommu_get_group_resv_regions(struct iommu_group *group,
466 mutex_lock(&group->mutex);
467 list_for_each_entry(device, &group->devices, list) {
477 mutex_unlock(&group->mutex);
482 static ssize_t iommu_group_show_resv_regions(struct iommu_group *group,
490 iommu_get_group_resv_regions(group, &group_resv_regions);
504 static ssize_t iommu_group_show_type(struct iommu_group *group,
509 if (group->default_domain) {
510 switch (group->default_domain->type) {
539 struct iommu_group *group = to_iommu_group(kobj);
541 pr_debug("Releasing group %d\n", group->id);
543 if (group->iommu_data_release)
544 group->iommu_data_release(group->iommu_data);
546 ida_simple_remove(&iommu_group_ida, group->id);
548 if (group->default_domain)
549 iommu_domain_free(group->default_domain);
551 kfree(group->name);
552 kfree(group);
561 * iommu_group_alloc - Allocate a new group
564 * group. The iommu group represents the minimum granularity of the iommu.
566 * group in order to hold the group until devices are added. Use
568 * group to be automatically reclaimed once it has no devices or external
573 struct iommu_group *group;
576 group = kzalloc(sizeof(*group), GFP_KERNEL);
577 if (!group)
580 group->kobj.kset = iommu_group_kset;
581 mutex_init(&group->mutex);
582 INIT_LIST_HEAD(&group->devices);
583 INIT_LIST_HEAD(&group->entry);
584 BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
588 kfree(group);
591 group->id = ret;
593 ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
594 NULL, "%d", group->id);
596 ida_simple_remove(&iommu_group_ida, group->id);
597 kobject_put(&group->kobj);
601 group->devices_kobj = kobject_create_and_add("devices", &group->kobj);
602 if (!group->devices_kobj) {
603 kobject_put(&group->kobj); /* triggers .release & free */
608 * The devices_kobj holds a reference on the group kobject, so
609 * as long as that exists so will the group. We can therefore
612 kobject_put(&group->kobj);
614 ret = iommu_group_create_file(group,
619 ret = iommu_group_create_file(group, &iommu_group_attr_type);
623 pr_debug("Allocated group %d\n", group->id);
625 return group;
632 struct iommu_group *group;
648 group = container_of(group_kobj, struct iommu_group, kobj);
649 BUG_ON(group->id != id);
651 kobject_get(group->devices_kobj);
652 kobject_put(&group->kobj);
654 return group;
659 * iommu_group_get_iommudata - retrieve iommu_data registered for a group
660 * @group: the group
662 * iommu drivers can store data in the group for use when doing iommu
664 * should hold a group reference.
666 void *iommu_group_get_iommudata(struct iommu_group *group)
668 return group->iommu_data;
673 * iommu_group_set_iommudata - set iommu_data for a group
674 * @group: the group
678 * iommu drivers can store data in the group for use when doing iommu
680 * the group has been allocated. Caller should hold a group reference.
682 void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
685 group->iommu_data = iommu_data;
686 group->iommu_data_release = release;
691 * iommu_group_set_name - set name for a group
692 * @group: the group
695 * Allow iommu driver to set a name for a group. When set it will
696 * appear in a name attribute file under the group in sysfs.
698 int iommu_group_set_name(struct iommu_group *group, const char *name)
702 if (group->name) {
703 iommu_group_remove_file(group, &iommu_group_attr_name);
704 kfree(group->name);
705 group->name = NULL;
710 group->name = kstrdup(name, GFP_KERNEL);
711 if (!group->name)
714 ret = iommu_group_create_file(group, &iommu_group_attr_name);
716 kfree(group->name);
717 group->name = NULL;
725 static int iommu_create_device_direct_mappings(struct iommu_group *group,
728 struct iommu_domain *domain = group->default_domain;
790 * iommu_group_add_device - add a device to an iommu group
791 * @group: the group into which to add the device (reference should be held)
795 * group. Adding a device increments the group reference count.
797 int iommu_group_add_device(struct iommu_group *group, struct device *dev)
808 ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group");
819 ret = sysfs_create_link_nowarn(group->devices_kobj,
835 kobject_get(group->devices_kobj);
837 dev->iommu_group = group;
839 mutex_lock(&group->mutex);
840 list_add_tail(&device->list, &group->devices);
841 if (group->domain && !iommu_is_attach_deferred(group->domain, dev))
842 ret = __iommu_attach_device(group->domain, dev);
843 mutex_unlock(&group->mutex);
847 /* Notify any listeners about change to group. */
848 blocking_notifier_call_chain(&group->notifier,
851 trace_add_device_to_group(group->id, dev);
853 dev_info(dev, "Adding to iommu group %d\n", group->id);
858 mutex_lock(&group->mutex);
860 mutex_unlock(&group->mutex);
862 kobject_put(group->devices_kobj);
863 sysfs_remove_link(group->devices_kobj, device->name);
870 dev_err(dev, "Failed to add to iommu group %d: %d\n", group->id, ret);
876 * iommu_group_remove_device - remove a device from it's current group
880 * it's current group. This decrements the iommu group reference count.
884 struct iommu_group *group = dev->iommu_group;
887 if (!group)
890 dev_info(dev, "Removing from iommu group %d\n", group->id);
893 blocking_notifier_call_chain(&group->notifier,
896 mutex_lock(&group->mutex);
897 list_for_each_entry(tmp_device, &group->devices, list) {
904 mutex_unlock(&group->mutex);
909 sysfs_remove_link(group->devices_kobj, device->name);
912 trace_remove_device_from_group(group->id, dev);
917 kobject_put(group->devices_kobj);
921 static int iommu_group_device_count(struct iommu_group *group)
926 list_for_each_entry(entry, &group->devices, list)
933 * iommu_group_for_each_dev - iterate over each device in the group
934 * @group: the group
938 * This function is called by group users to iterate over group devices.
939 * Callers should hold a reference count to the group during callback.
940 * The group->mutex is held across callbacks, which will block calls to
943 static int __iommu_group_for_each_dev(struct iommu_group *group, void *data,
949 list_for_each_entry(device, &group->devices, list) {
958 int iommu_group_for_each_dev(struct iommu_group *group, void *data,
963 mutex_lock(&group->mutex);
964 ret = __iommu_group_for_each_dev(group, data, fn);
965 mutex_unlock(&group->mutex);
972 * iommu_group_get - Return the group for a device and increment reference
973 * @dev: get the group that this device belongs to
975 * This function is called by iommu drivers and users to get the group
976 * for the specified device. If found, the group is returned and the group
981 struct iommu_group *group = dev->iommu_group;
983 if (group)
984 kobject_get(group->devices_kobj);
986 return group;
991 * iommu_group_ref_get - Increment reference on a group
992 * @group: the group to use, must not be NULL
995 * existing group. Returns the given group for convenience.
997 struct iommu_group *iommu_group_ref_get(struct iommu_group *group)
999 kobject_get(group->devices_kobj);
1000 return group;
1005 * iommu_group_put - Decrement group reference
1006 * @group: the group to use
1009 * iommu group. Once the reference count is zero, the group is released.
1011 void iommu_group_put(struct iommu_group *group)
1013 if (group)
1014 kobject_put(group->devices_kobj);
1019 * iommu_group_register_notifier - Register a notifier for group changes
1020 * @group: the group to watch
1023 * This function allows iommu group users to track changes in a group.
1025 * should hold a reference to the group throughout notifier registration.
1027 int iommu_group_register_notifier(struct iommu_group *group,
1030 return blocking_notifier_chain_register(&group->notifier, nb);
1036 * @group: the group to watch
1039 * Unregister a previously registered group notifier block.
1041 int iommu_group_unregister_notifier(struct iommu_group *group,
1044 return blocking_notifier_chain_unregister(&group->notifier, nb);
1233 * matched using the group ID, the PASID valid bit and the PASID
1234 * value. Otherwise only the group ID matches request and
1260 * iommu_group_id - Return ID for a group
1261 * @group: the group to ID
1263 * Return the unique ID for the group matching the sysfs group number.
1265 int iommu_group_id(struct iommu_group *group)
1267 return group->id;
1288 * that may already have a group.
1294 struct iommu_group *group;
1305 group = get_pci_alias_group(tmp, devfns);
1306 if (group) {
1308 return group;
1328 struct iommu_group *group;
1333 group = iommu_group_get(&pdev->dev);
1334 if (group)
1335 return group;
1343 group = get_pci_alias_group(tmp, devfns);
1344 if (group) {
1346 return group;
1349 group = get_pci_function_alias_group(tmp, devfns);
1350 if (group) {
1352 return group;
1362 struct iommu_group *group;
1367 * the IOMMU group if we find one along the way.
1374 data->group = iommu_group_get(&pdev->dev);
1376 return data->group != NULL;
1381 * iommu-group per device.
1391 * to find or create an IOMMU group for a device.
1398 struct iommu_group *group = NULL;
1406 * be aliased due to topology in order to have its own IOMMU group.
1408 * group, use it.
1411 return data.group;
1419 * group, use it.
1430 group = iommu_group_get(&pdev->dev);
1431 if (group)
1432 return group;
1437 * device or another device aliases us, use the same group.
1439 group = get_pci_alias_group(pdev, (unsigned long *)devfns);
1440 if (group)
1441 return group;
1448 group = get_pci_function_alias_group(pdev, (unsigned long *)devfns);
1449 if (group)
1450 return group;
1452 /* No shared group found, allocate new */
1457 /* Get the IOMMU group for device on fsl-mc bus */
1461 struct iommu_group *group;
1463 group = iommu_group_get(cont_dev);
1464 if (!group)
1465 group = iommu_group_alloc();
1466 return group;
1482 struct iommu_group *group,
1491 pr_warn("Failed to allocate default IOMMU domain of type %u for group %s - Falling back to IOMMU_DOMAIN_DMA",
1492 type, group->name);
1498 group->default_domain = dom;
1499 if (!group->domain)
1500 group->domain = dom;
1512 static int iommu_alloc_default_domain(struct iommu_group *group,
1517 if (group->default_domain)
1522 return iommu_group_alloc_default_domain(dev->bus, group, type);
1526 * iommu_group_get_for_dev - Find or create the IOMMU group for a device
1531 * IOMMU group for a device. On success, the caller will hold a reference
1532 * to the returned IOMMU group, which will already include the provided
1538 struct iommu_group *group;
1541 group = iommu_group_get(dev);
1542 if (group)
1543 return group;
1548 group = ops->device_group(dev);
1549 if (WARN_ON_ONCE(group == NULL))
1552 if (IS_ERR(group))
1553 return group;
1555 ret = iommu_group_add_device(group, dev);
1559 return group;
1562 iommu_group_put(group);
1567 struct iommu_domain *iommu_group_default_domain(struct iommu_group *group)
1569 return group->default_domain;
1575 struct iommu_group *group;
1578 /* Device is probed already if in a group */
1579 group = iommu_group_get(dev);
1580 if (group) {
1581 iommu_group_put(group);
1604 struct iommu_group *group;
1608 * result in ADD/DEL notifiers to group->notifier
1622 * group, if anyone is listening
1624 group = iommu_group_get(dev);
1625 if (!group)
1644 blocking_notifier_call_chain(&group->notifier,
1647 iommu_group_put(group);
1667 dev_warn(dev, "Device needs domain type %s, but device %s in the same iommu group requires type %s - using default\n",
1684 struct iommu_group *group)
1690 /* Ask for default domain requirements of all devices in the group */
1691 __iommu_group_for_each_dev(group, >ype,
1697 iommu_group_alloc_default_domain(bus, group, gtype.type);
1712 static int __iommu_group_dma_attach(struct iommu_group *group)
1714 return __iommu_group_for_each_dev(group, group->default_domain,
1728 static void __iommu_group_dma_finalize(struct iommu_group *group)
1730 __iommu_group_for_each_dev(group, group->default_domain,
1736 struct iommu_group *group = data;
1738 iommu_create_device_direct_mappings(group, dev);
1743 static int iommu_group_create_direct_mappings(struct iommu_group *group)
1745 return __iommu_group_for_each_dev(group, group,
1751 struct iommu_group *group, *next;
1757 * creating the iommu group, so do it after the groups are
1764 list_for_each_entry_safe(group, next, &group_list, entry) {
1766 list_del_init(&group->entry);
1768 mutex_lock(&group->mutex);
1771 probe_alloc_default_domain(bus, group);
1773 if (!group->default_domain) {
1774 mutex_unlock(&group->mutex);
1778 iommu_group_create_direct_mappings(group);
1780 ret = __iommu_group_dma_attach(group);
1782 mutex_unlock(&group->mutex);
1787 __iommu_group_dma_finalize(group);
1948 struct iommu_group *group;
1951 group = iommu_group_get(dev);
1952 if (!group)
1956 * Lock the group to make sure the device-count doesn't
1959 mutex_lock(&group->mutex);
1961 if (iommu_group_device_count(group) != 1)
1964 ret = __iommu_attach_group(domain, group);
1967 mutex_unlock(&group->mutex);
1968 iommu_group_put(group);
2199 struct iommu_group *group;
2201 group = iommu_group_get(dev);
2202 if (!group)
2205 mutex_lock(&group->mutex);
2206 if (iommu_group_device_count(group) != 1) {
2211 __iommu_detach_group(domain, group);
2214 mutex_unlock(&group->mutex);
2215 iommu_group_put(group);
2222 struct iommu_group *group;
2224 group = iommu_group_get(dev);
2225 if (!group)
2228 domain = group->domain;
2230 iommu_group_put(group);
2238 * guarantees that the group and its default domain are valid and correct.
2248 * iterating over the devices in a group. Ideally we'd have a single
2249 * device which represents the requestor ID of the group, but we also
2252 * wish to group them at a higher level (ex. untrusted multi-function
2263 struct iommu_group *group)
2267 if (group->default_domain && group->domain != group->default_domain)
2270 ret = __iommu_group_for_each_dev(group, domain,
2273 group->domain = domain;
2278 int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
2282 mutex_lock(&group->mutex);
2283 ret = __iommu_attach_group(domain, group);
2284 mutex_unlock(&group->mutex);
2300 struct iommu_group *group)
2304 if (!group->default_domain) {
2305 __iommu_group_for_each_dev(group, domain,
2307 group->domain = NULL;
2311 if (group->domain == group->default_domain)
2315 ret = __iommu_group_for_each_dev(group, group->default_domain,
2320 group->domain = group->default_domain;
2323 void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
2325 mutex_lock(&group->mutex);
2326 __iommu_detach_group(domain, group);
2327 mutex_unlock(&group->mutex);
2987 struct iommu_group *group;
2994 group = iommu_group_get(dev);
2995 if (!group)
2999 mutex_lock(&group->mutex);
3007 if (iommu_group_device_count(group) != 1)
3013 mutex_unlock(&group->mutex);
3014 iommu_group_put(group);
3032 struct iommu_group *group;
3039 group = iommu_group_get(dev);
3040 if (!group)
3043 mutex_lock(&group->mutex);
3045 mutex_unlock(&group->mutex);
3047 iommu_group_put(group);