iommu: IOMMU Groups

IOMMU device groups are currently a rather vague associative notion
with assembly required by the user or user level driver provider to
do anything useful.  This patch intends to grow the IOMMU group concept
into something a bit more consumable.

To do this, we first create an object representing the group, struct
iommu_group.  This structure is allocated (iommu_group_alloc) and
filled (iommu_group_add_device) by the iommu driver.  The iommu driver
is free to add devices to the group using it's own set of policies.
This allows inclusion of devices based on physical hardware or topology
limitations of the platform, as well as soft requirements, such as
multi-function trust levels or peer-to-peer protection of the
interconnects.  Each device may only belong to a single iommu group,
which is linked from struct device.iommu_group.  IOMMU groups are
maintained using kobject reference counting, allowing for automatic
removal of empty, unreferenced groups.  It is the responsibility of
the iommu driver to remove devices from the group
(iommu_group_remove_device).

IOMMU groups also include a userspace representation in sysfs under
/sys/kernel/iommu_groups.  When allocated, each group is given a
dynamically assign ID (int).  The ID is managed by the core IOMMU group
code to support multiple heterogeneous iommu drivers, which could
potentially collide in group naming/numbering.  This also keeps group
IDs to small, easily managed values.  A directory is created under
/sys/kernel/iommu_groups for each group.  A further subdirectory named
"devices" contains links to each device within the group.  The iommu_group
file in the device's sysfs directory, which formerly contained a group
number when read, is now a link to the iommu group.  Example:

$ ls -l /sys/kernel/iommu_groups/26/devices/
total 0
lrwxrwxrwx. 1 root root 0 Apr 17 12:57 0000:00:1e.0 ->
		../../../../devices/pci0000:00/0000:00:1e.0
lrwxrwxrwx. 1 root root 0 Apr 17 12:57 0000:06:0d.0 ->
		../../../../devices/pci0000:00/0000:00:1e.0/0000:06:0d.0
lrwxrwxrwx. 1 root root 0 Apr 17 12:57 0000:06:0d.1 ->
		../../../../devices/pci0000:00/0000:00:1e.0/0000:06:0d.1

$ ls -l  /sys/kernel/iommu_groups/26/devices/*/iommu_group
[truncating perms/owner/timestamp]
/sys/kernel/iommu_groups/26/devices/0000:00:1e.0/iommu_group ->
					../../../kernel/iommu_groups/26
/sys/kernel/iommu_groups/26/devices/0000:06:0d.0/iommu_group ->
					../../../../kernel/iommu_groups/26
/sys/kernel/iommu_groups/26/devices/0000:06:0d.1/iommu_group ->
					../../../../kernel/iommu_groups/26

Groups also include several exported functions for use by user level
driver providers, for example VFIO.  These include:

iommu_group_get(): Acquires a reference to a group from a device
iommu_group_put(): Releases reference
iommu_group_for_each_dev(): Iterates over group devices using callback
iommu_group_[un]register_notifier(): Allows notification of device add
        and remove operations relevant to the group
iommu_group_id(): Return the group number

This patch also extends the IOMMU API to allow attaching groups to
domains.  This is currently a simple wrapper for iterating through
devices within a group, but it's expected that the IOMMU API may
eventually make groups a more integral part of domains.

Groups intentionally do not try to manage group ownership.  A user
level driver provider must independently acquire ownership for each
device within a group before making use of the group as a whole.
This may change in the future if group usage becomes more pervasive
across both DMA and IOMMU ops.

Groups intentionally do not provide a mechanism for driver locking
or otherwise manipulating driver matching/probing of devices within
the group.  Such interfaces are generic to devices and beyond the
scope of IOMMU groups.  If implemented, user level providers have
ready access via iommu_group_for_each_dev and group notifiers.

iommu_device_group() is removed here as it has no users.  The
replacement is:

	group = iommu_group_get(dev);
	id = iommu_group_id(group);
	iommu_group_put(group);

AMD-Vi & Intel VT-d support re-added in following patches.

Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Joerg Roedel <joerg.roedel@amd.com>

3 files changed, 548 insertions, 100 deletions

diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index a2e418cba0ff..55283d6291c8 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -3227,26 +3227,6 @@ static int amd_iommu_domain_has_cap(struct iommu_domain *domain,
         return 0;
 }
 
-static int amd_iommu_device_group(struct device *dev, unsigned int *groupid)
-{
-        struct iommu_dev_data *dev_data = dev->archdata.iommu;
-        struct pci_dev *pdev = to_pci_dev(dev);
-        u16 devid;
-
-        if (!dev_data)
-                return -ENODEV;
-
-        if (pdev->is_virtfn || !iommu_group_mf)
-                devid = dev_data->devid;
-        else
-                devid = calc_devid(pdev->bus->number,
-                                   PCI_DEVFN(PCI_SLOT(pdev->devfn), 0));
-
-        *groupid = amd_iommu_alias_table[devid];
-
-        return 0;
-}
-
 static struct iommu_ops amd_iommu_ops = {
         .domain_init = amd_iommu_domain_init,
         .domain_destroy = amd_iommu_domain_destroy,
@@ -3256,7 +3236,6 @@ static struct iommu_ops amd_iommu_ops = {
         .unmap = amd_iommu_unmap,
         .iova_to_phys = amd_iommu_iova_to_phys,
         .domain_has_cap = amd_iommu_domain_has_cap,
-        .device_group = amd_iommu_device_group,
         .pgsize_bitmap  = AMD_IOMMU_PGSIZES,
 };
 
diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
index b12af2ff8c54..c62f2df25221 100644
--- a/drivers/iommu/intel-iommu.c
+++ b/drivers/iommu/intel-iommu.c
@@ -4090,54 +4090,6 @@ static int intel_iommu_domain_has_cap(struct iommu_domain *domain,
         return 0;
 }
 
-/*
- * Group numbers are arbitrary.  Device with the same group number
- * indicate the iommu cannot differentiate between them.  To avoid
- * tracking used groups we just use the seg|bus|devfn of the lowest
- * level we're able to differentiate devices
- */
-static int intel_iommu_device_group(struct device *dev, unsigned int *groupid)
-{
-        struct pci_dev *pdev = to_pci_dev(dev);
-        struct pci_dev *bridge;
-        union {
-                struct {
-                        u8 devfn;
-                        u8 bus;
-                        u16 segment;
-                } pci;
-                u32 group;
-        } id;
-
-        if (iommu_no_mapping(dev))
-                return -ENODEV;
-
-        id.pci.segment = pci_domain_nr(pdev->bus);
-        id.pci.bus = pdev->bus->number;
-        id.pci.devfn = pdev->devfn;
-
-        if (!device_to_iommu(id.pci.segment, id.pci.bus, id.pci.devfn))
-                return -ENODEV;
-
-        bridge = pci_find_upstream_pcie_bridge(pdev);
-        if (bridge) {
-                if (pci_is_pcie(bridge)) {
-                        id.pci.bus = bridge->subordinate->number;
-                        id.pci.devfn = 0;
-                } else {
-                        id.pci.bus = bridge->bus->number;
-                        id.pci.devfn = bridge->devfn;
-                }
-        }
-
-        if (!pdev->is_virtfn && iommu_group_mf)
-                id.pci.devfn = PCI_DEVFN(PCI_SLOT(id.pci.devfn), 0);
-
-        *groupid = id.group;
-
-        return 0;
-}
-
 static struct iommu_ops intel_iommu_ops = {
         .domain_init    = intel_iommu_domain_init,
         .domain_destroy = intel_iommu_domain_destroy,
@@ -4147,7 +4099,6 @@ static struct iommu_ops intel_iommu_ops = {
         .unmap          = intel_iommu_unmap,
         .iova_to_phys   = intel_iommu_iova_to_phys,
         .domain_has_cap = intel_iommu_domain_has_cap,
-        .device_group   = intel_iommu_device_group,
         .pgsize_bitmap  = INTEL_IOMMU_PGSIZES,
 };
 
diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
index 8b9ded88e6f5..0e928acd7dcf 100644
--- a/drivers/iommu/iommu.c
+++ b/drivers/iommu/iommu.c
@@ -26,60 +26,535 @@
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/iommu.h>
+#include <linux/idr.h>
+#include <linux/notifier.h>
+#include <linux/err.h>
+
+static struct kset *iommu_group_kset;
+static struct ida iommu_group_ida;
+static struct mutex iommu_group_mutex;
+
+struct iommu_group {
+        struct kobject kobj;
+        struct kobject *devices_kobj;
+        struct list_head devices;
+        struct mutex mutex;
+        struct blocking_notifier_head notifier;
+        void *iommu_data;
+        void (*iommu_data_release)(void *iommu_data);
+        char *name;
+        int id;
+};
+
+struct iommu_device {
+        struct list_head list;
+        struct device *dev;
+        char *name;
+};
+
+struct iommu_group_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct iommu_group *group, char *buf);
+        ssize_t (*store)(struct iommu_group *group,
+                         const char *buf, size_t count);
+};
+
+#define IOMMU_GROUP_ATTR(_name, _mode, _show, _store)           \
+struct iommu_group_attribute iommu_group_attr_##_name =         \
+        __ATTR(_name, _mode, _show, _store)
 
-static ssize_t show_iommu_group(struct device *dev,
-                                struct device_attribute *attr, char *buf)
+#define to_iommu_group_attr(_attr)      \
+        container_of(_attr, struct iommu_group_attribute, attr)
+#define to_iommu_group(_kobj)           \
+        container_of(_kobj, struct iommu_group, kobj)
+
+static ssize_t iommu_group_attr_show(struct kobject *kobj,
+                                     struct attribute *__attr, char *buf)
 {
-        unsigned int groupid;
+        struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
+        struct iommu_group *group = to_iommu_group(kobj);
+        ssize_t ret = -EIO;
 
-        if (iommu_device_group(dev, &groupid))
-                return 0;
+        if (attr->show)
+                ret = attr->show(group, buf);
+        return ret;
+}
+
+static ssize_t iommu_group_attr_store(struct kobject *kobj,
+                                      struct attribute *__attr,
+                                      const char *buf, size_t count)
+{
+        struct iommu_group_attribute *attr = to_iommu_group_attr(__attr);
+        struct iommu_group *group = to_iommu_group(kobj);
+        ssize_t ret = -EIO;
 
-        return sprintf(buf, "%u", groupid);
+        if (attr->store)
+                ret = attr->store(group, buf, count);
+        return ret;
 }
-static DEVICE_ATTR(iommu_group, S_IRUGO, show_iommu_group, NULL);
 
-static int add_iommu_group(struct device *dev, void *data)
+static const struct sysfs_ops iommu_group_sysfs_ops = {
+        .show = iommu_group_attr_show,
+        .store = iommu_group_attr_store,
+};
+
+static int iommu_group_create_file(struct iommu_group *group,
+                                   struct iommu_group_attribute *attr)
+{
+        return sysfs_create_file(&group->kobj, &attr->attr);
+}
+
+static void iommu_group_remove_file(struct iommu_group *group,
+                                    struct iommu_group_attribute *attr)
+{
+        sysfs_remove_file(&group->kobj, &attr->attr);
+}
+
+static ssize_t iommu_group_show_name(struct iommu_group *group, char *buf)
+{
+        return sprintf(buf, "%s\n", group->name);
+}
+
+static IOMMU_GROUP_ATTR(name, S_IRUGO, iommu_group_show_name, NULL);
+
+static void iommu_group_release(struct kobject *kobj)
+{
+        struct iommu_group *group = to_iommu_group(kobj);
+
+        if (group->iommu_data_release)
+                group->iommu_data_release(group->iommu_data);
+
+        mutex_lock(&iommu_group_mutex);
+        ida_remove(&iommu_group_ida, group->id);
+        mutex_unlock(&iommu_group_mutex);
+
+        kfree(group->name);
+        kfree(group);
+}
+
+static struct kobj_type iommu_group_ktype = {
+        .sysfs_ops = &iommu_group_sysfs_ops,
+        .release = iommu_group_release,
+};
+
+/**
+ * iommu_group_alloc - Allocate a new group
+ * @name: Optional name to associate with group, visible in sysfs
+ *
+ * This function is called by an iommu driver to allocate a new iommu
+ * group.  The iommu group represents the minimum granularity of the iommu.
+ * Upon successful return, the caller holds a reference to the supplied
+ * group in order to hold the group until devices are added.  Use
+ * iommu_group_put() to release this extra reference count, allowing the
+ * group to be automatically reclaimed once it has no devices or external
+ * references.
+ */
+struct iommu_group *iommu_group_alloc(void)
 {
-        unsigned int groupid;
+        struct iommu_group *group;
+        int ret;
+
+        group = kzalloc(sizeof(*group), GFP_KERNEL);
+        if (!group)
+                return ERR_PTR(-ENOMEM);
+
+        group->kobj.kset = iommu_group_kset;
+        mutex_init(&group->mutex);
+        INIT_LIST_HEAD(&group->devices);
+        BLOCKING_INIT_NOTIFIER_HEAD(&group->notifier);
+
+        mutex_lock(&iommu_group_mutex);
+
+again:
+        if (unlikely(0 == ida_pre_get(&iommu_group_ida, GFP_KERNEL))) {
+                kfree(group);
+                mutex_unlock(&iommu_group_mutex);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        if (-EAGAIN == ida_get_new(&iommu_group_ida, &group->id))
+                goto again;
+
+        mutex_unlock(&iommu_group_mutex);
 
-        if (iommu_device_group(dev, &groupid) == 0)
-                return device_create_file(dev, &dev_attr_iommu_group);
+        ret = kobject_init_and_add(&group->kobj, &iommu_group_ktype,
+                                   NULL, "%d", group->id);
+        if (ret) {
+                mutex_lock(&iommu_group_mutex);
+                ida_remove(&iommu_group_ida, group->id);
+                mutex_unlock(&iommu_group_mutex);
+                kfree(group);
+                return ERR_PTR(ret);
+        }
+
+        group->devices_kobj = kobject_create_and_add("devices", &group->kobj);
+        if (!group->devices_kobj) {
+                kobject_put(&group->kobj); /* triggers .release & free */
+                return ERR_PTR(-ENOMEM);
+        }
+
+        /*
+         * The devices_kobj holds a reference on the group kobject, so
+         * as long as that exists so will the group.  We can therefore
+         * use the devices_kobj for reference counting.
+         */
+        kobject_put(&group->kobj);
+
+        return group;
+}
+EXPORT_SYMBOL_GPL(iommu_group_alloc);
+
+/**
+ * iommu_group_get_iommudata - retrieve iommu_data registered for a group
+ * @group: the group
+ *
+ * iommu drivers can store data in the group for use when doing iommu
+ * operations.  This function provides a way to retrieve it.  Caller
+ * should hold a group reference.
+ */
+void *iommu_group_get_iommudata(struct iommu_group *group)
+{
+        return group->iommu_data;
+}
+EXPORT_SYMBOL_GPL(iommu_group_get_iommudata);
+
+/**
+ * iommu_group_set_iommudata - set iommu_data for a group
+ * @group: the group
+ * @iommu_data: new data
+ * @release: release function for iommu_data
+ *
+ * iommu drivers can store data in the group for use when doing iommu
+ * operations.  This function provides a way to set the data after
+ * the group has been allocated.  Caller should hold a group reference.
+ */
+void iommu_group_set_iommudata(struct iommu_group *group, void *iommu_data,
+                               void (*release)(void *iommu_data))
+{
+        group->iommu_data = iommu_data;
+        group->iommu_data_release = release;
+}
+EXPORT_SYMBOL_GPL(iommu_group_set_iommudata);
+
+/**
+ * iommu_group_set_name - set name for a group
+ * @group: the group
+ * @name: name
+ *
+ * Allow iommu driver to set a name for a group.  When set it will
+ * appear in a name attribute file under the group in sysfs.
+ */
+int iommu_group_set_name(struct iommu_group *group, const char *name)
+{
+        int ret;
+
+        if (group->name) {
+                iommu_group_remove_file(group, &iommu_group_attr_name);
+                kfree(group->name);
+                group->name = NULL;
+                if (!name)
+                        return 0;
+        }
+
+        group->name = kstrdup(name, GFP_KERNEL);
+        if (!group->name)
+                return -ENOMEM;
+
+        ret = iommu_group_create_file(group, &iommu_group_attr_name);
+        if (ret) {
+                kfree(group->name);
+                group->name = NULL;
+                return ret;
+        }
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(iommu_group_set_name);
 
-static int remove_iommu_group(struct device *dev)
+/**
+ * iommu_group_add_device - add a device to an iommu group
+ * @group: the group into which to add the device (reference should be held)
+ * @dev: the device
+ *
+ * This function is called by an iommu driver to add a device into a
+ * group.  Adding a device increments the group reference count.
+ */
+int iommu_group_add_device(struct iommu_group *group, struct device *dev)
 {
-        unsigned int groupid;
+        int ret, i = 0;
+        struct iommu_device *device;
+
+        device = kzalloc(sizeof(*device), GFP_KERNEL);
+        if (!device)
+                return -ENOMEM;
+
+        device->dev = dev;
 
-        if (iommu_device_group(dev, &groupid) == 0)
-                device_remove_file(dev, &dev_attr_iommu_group);
+        ret = sysfs_create_link(&dev->kobj, &group->kobj, "iommu_group");
+        if (ret) {
+                kfree(device);
+                return ret;
+        }
+
+        device->name = kasprintf(GFP_KERNEL, "%s", kobject_name(&dev->kobj));
+rename:
+        if (!device->name) {
+                sysfs_remove_link(&dev->kobj, "iommu_group");
+                kfree(device);
+                return -ENOMEM;
+        }
 
+        ret = sysfs_create_link_nowarn(group->devices_kobj,
+                                       &dev->kobj, device->name);
+        if (ret) {
+                kfree(device->name);
+                if (ret == -EEXIST && i >= 0) {
+                        /*
+                         * Account for the slim chance of collision
+                         * and append an instance to the name.
+                         */
+                        device->name = kasprintf(GFP_KERNEL, "%s.%d",
+                                                 kobject_name(&dev->kobj), i++);
+                        goto rename;
+                }
+
+                sysfs_remove_link(&dev->kobj, "iommu_group");
+                kfree(device);
+                return ret;
+        }
+
+        kobject_get(group->devices_kobj);
+
+        dev->iommu_group = group;
+
+        mutex_lock(&group->mutex);
+        list_add_tail(&device->list, &group->devices);
+        mutex_unlock(&group->mutex);
+
+        /* Notify any listeners about change to group. */
+        blocking_notifier_call_chain(&group->notifier,
+                                     IOMMU_GROUP_NOTIFY_ADD_DEVICE, dev);
         return 0;
 }
+EXPORT_SYMBOL_GPL(iommu_group_add_device);
 
-static int iommu_device_notifier(struct notifier_block *nb,
-                                 unsigned long action, void *data)
+/**
+ * iommu_group_remove_device - remove a device from it's current group
+ * @dev: device to be removed
+ *
+ * This function is called by an iommu driver to remove the device from
+ * it's current group.  This decrements the iommu group reference count.
+ */
+void iommu_group_remove_device(struct device *dev)
+{
+        struct iommu_group *group = dev->iommu_group;
+        struct iommu_device *tmp_device, *device = NULL;
+
+        /* Pre-notify listeners that a device is being removed. */
+        blocking_notifier_call_chain(&group->notifier,
+                                     IOMMU_GROUP_NOTIFY_DEL_DEVICE, dev);
+
+        mutex_lock(&group->mutex);
+        list_for_each_entry(tmp_device, &group->devices, list) {
+                if (tmp_device->dev == dev) {
+                        device = tmp_device;
+                        list_del(&device->list);
+                        break;
+                }
+        }
+        mutex_unlock(&group->mutex);
+
+        if (!device)
+                return;
+
+        sysfs_remove_link(group->devices_kobj, device->name);
+        sysfs_remove_link(&dev->kobj, "iommu_group");
+
+        kfree(device->name);
+        kfree(device);
+        dev->iommu_group = NULL;
+        kobject_put(group->devices_kobj);
+}
+EXPORT_SYMBOL_GPL(iommu_group_remove_device);
+
+/**
+ * iommu_group_for_each_dev - iterate over each device in the group
+ * @group: the group
+ * @data: caller opaque data to be passed to callback function
+ * @fn: caller supplied callback function
+ *
+ * This function is called by group users to iterate over group devices.
+ * Callers should hold a reference count to the group during callback.
+ * The group->mutex is held across callbacks, which will block calls to
+ * iommu_group_add/remove_device.
+ */
+int iommu_group_for_each_dev(struct iommu_group *group, void *data,
+                             int (*fn)(struct device *, void *))
+{
+        struct iommu_device *device;
+        int ret = 0;
+
+        mutex_lock(&group->mutex);
+        list_for_each_entry(device, &group->devices, list) {
+                ret = fn(device->dev, data);
+                if (ret)
+                        break;
+        }
+        mutex_unlock(&group->mutex);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(iommu_group_for_each_dev);
+
+/**
+ * iommu_group_get - Return the group for a device and increment reference
+ * @dev: get the group that this device belongs to
+ *
+ * This function is called by iommu drivers and users to get the group
+ * for the specified device.  If found, the group is returned and the group
+ * reference in incremented, else NULL.
+ */
+struct iommu_group *iommu_group_get(struct device *dev)
+{
+        struct iommu_group *group = dev->iommu_group;
+
+        if (group)
+                kobject_get(group->devices_kobj);
+
+        return group;
+}
+EXPORT_SYMBOL_GPL(iommu_group_get);
+
+/**
+ * iommu_group_put - Decrement group reference
+ * @group: the group to use
+ *
+ * This function is called by iommu drivers and users to release the
+ * iommu group.  Once the reference count is zero, the group is released.
+ */
+void iommu_group_put(struct iommu_group *group)
+{
+        if (group)
+                kobject_put(group->devices_kobj);
+}
+EXPORT_SYMBOL_GPL(iommu_group_put);
+
+/**
+ * iommu_group_register_notifier - Register a notifier for group changes
+ * @group: the group to watch
+ * @nb: notifier block to signal
+ *
+ * This function allows iommu group users to track changes in a group.
+ * See include/linux/iommu.h for actions sent via this notifier.  Caller
+ * should hold a reference to the group throughout notifier registration.
+ */
+int iommu_group_register_notifier(struct iommu_group *group,
+                                  struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&group->notifier, nb);
+}
+EXPORT_SYMBOL_GPL(iommu_group_register_notifier);
+
+/**
+ * iommu_group_unregister_notifier - Unregister a notifier
+ * @group: the group to watch
+ * @nb: notifier block to signal
+ *
+ * Unregister a previously registered group notifier block.
+ */
+int iommu_group_unregister_notifier(struct iommu_group *group,
+                                    struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&group->notifier, nb);
+}
+EXPORT_SYMBOL_GPL(iommu_group_unregister_notifier);
+
+/**
+ * iommu_group_id - Return ID for a group
+ * @group: the group to ID
+ *
+ * Return the unique ID for the group matching the sysfs group number.
+ */
+int iommu_group_id(struct iommu_group *group)
+{
+        return group->id;
+}
+EXPORT_SYMBOL_GPL(iommu_group_id);
+
+static int add_iommu_group(struct device *dev, void *data)
+{
+        struct iommu_ops *ops = data;
+
+        if (!ops->add_device)
+                return -ENODEV;
+
+        WARN_ON(dev->iommu_group);
+
+        ops->add_device(dev);
+
+        return 0;
+}
+
+static int iommu_bus_notifier(struct notifier_block *nb,
+                              unsigned long action, void *data)
 {
         struct device *dev = data;
+        struct iommu_ops *ops = dev->bus->iommu_ops;
+        struct iommu_group *group;
+        unsigned long group_action = 0;
+
+        /*
+         * ADD/DEL call into iommu driver ops if provided, which may
+         * result in ADD/DEL notifiers to group->notifier
+         */
+        if (action == BUS_NOTIFY_ADD_DEVICE) {
+                if (ops->add_device)
+                        return ops->add_device(dev);
+        } else if (action == BUS_NOTIFY_DEL_DEVICE) {
+                if (ops->remove_device && dev->iommu_group) {
+                        ops->remove_device(dev);
+                        return 0;
+                }
+        }
 
-        if (action == BUS_NOTIFY_ADD_DEVICE)
-                return add_iommu_group(dev, NULL);
-        else if (action == BUS_NOTIFY_DEL_DEVICE)
-                return remove_iommu_group(dev);
+        /*
+         * Remaining BUS_NOTIFYs get filtered and republished to the
+         * group, if anyone is listening
+         */
+        group = iommu_group_get(dev);
+        if (!group)
+                return 0;
 
+        switch (action) {
+        case BUS_NOTIFY_BIND_DRIVER:
+                group_action = IOMMU_GROUP_NOTIFY_BIND_DRIVER;
+                break;
+        case BUS_NOTIFY_BOUND_DRIVER:
+                group_action = IOMMU_GROUP_NOTIFY_BOUND_DRIVER;
+                break;
+        case BUS_NOTIFY_UNBIND_DRIVER:
+                group_action = IOMMU_GROUP_NOTIFY_UNBIND_DRIVER;
+                break;
+        case BUS_NOTIFY_UNBOUND_DRIVER:
+                group_action = IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER;
+                break;
+        }
+
+        if (group_action)
+                blocking_notifier_call_chain(&group->notifier,
+                                             group_action, dev);
+
+        iommu_group_put(group);
         return 0;
 }
 
-static struct notifier_block iommu_device_nb = {
-        .notifier_call = iommu_device_notifier,
+static struct notifier_block iommu_bus_nb = {
+        .notifier_call = iommu_bus_notifier,
 };
 
 static void iommu_bus_init(struct bus_type *bus, struct iommu_ops *ops)
 {
-        bus_register_notifier(bus, &iommu_device_nb);
-        bus_for_each_dev(bus, NULL, NULL, add_iommu_group);
+        bus_register_notifier(bus, &iommu_bus_nb);
+        bus_for_each_dev(bus, NULL, ops, add_iommu_group);
 }
 
 /**
@@ -192,6 +667,45 @@ void iommu_detach_device(struct iommu_domain *domain, struct device *dev)
 }
 EXPORT_SYMBOL_GPL(iommu_detach_device);
 
+/*
+ * IOMMU groups are really the natrual working unit of the IOMMU, but
+ * the IOMMU API works on domains and devices.  Bridge that gap by
+ * iterating over the devices in a group.  Ideally we'd have a single
+ * device which represents the requestor ID of the group, but we also
+ * allow IOMMU drivers to create policy defined minimum sets, where
+ * the physical hardware may be able to distiguish members, but we
+ * wish to group them at a higher level (ex. untrusted multi-function
+ * PCI devices).  Thus we attach each device.
+ */
+static int iommu_group_do_attach_device(struct device *dev, void *data)
+{
+        struct iommu_domain *domain = data;
+
+        return iommu_attach_device(domain, dev);
+}
+
+int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group)
+{
+        return iommu_group_for_each_dev(group, domain,
+                                        iommu_group_do_attach_device);
+}
+EXPORT_SYMBOL_GPL(iommu_attach_group);
+
+static int iommu_group_do_detach_device(struct device *dev, void *data)
+{
+        struct iommu_domain *domain = data;
+
+        iommu_detach_device(domain, dev);
+
+        return 0;
+}
+
+void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group)
+{
+        iommu_group_for_each_dev(group, domain, iommu_group_do_detach_device);
+}
+EXPORT_SYMBOL_GPL(iommu_detach_group);
+
 phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
                                unsigned long iova)
 {
@@ -336,11 +850,15 @@ size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
 }
 EXPORT_SYMBOL_GPL(iommu_unmap);
 
-int iommu_device_group(struct device *dev, unsigned int *groupid)
+static int __init iommu_init(void)
 {
-        if (iommu_present(dev->bus) && dev->bus->iommu_ops->device_group)
-                return dev->bus->iommu_ops->device_group(dev, groupid);
+        iommu_group_kset = kset_create_and_add("iommu_groups",
+                                               NULL, kernel_kobj);
+        ida_init(&iommu_group_ida);
+        mutex_init(&iommu_group_mutex);
 
-        return -ENODEV;
+        BUG_ON(!iommu_group_kset);
+
+        return 0;
 }
-EXPORT_SYMBOL_GPL(iommu_device_group);
+subsys_initcall(iommu_init);