vfio-pci: PCI hot reset interface

The current VFIO_DEVICE_RESET interface only maps to PCI use cases
where we can isolate the reset to the individual PCI function.  This
means the device must support FLR (PCIe or AF), PM reset on D3hot->D0
transition, device specific reset, or be a singleton device on a bus
for a secondary bus reset.  FLR does not have widespread support,
PM reset is not very reliable, and bus topology is dictated by the
system and device design.  We need to provide a means for a user to
induce a bus reset in cases where the existing mechanisms are not
available or not reliable.

This device specific extension to VFIO provides the user with this
ability.  Two new ioctls are introduced:
 - VFIO_DEVICE_PCI_GET_HOT_RESET_INFO
 - VFIO_DEVICE_PCI_HOT_RESET

The first provides the user with information about the extent of
devices affected by a hot reset.  This is essentially a list of
devices and the IOMMU groups they belong to.  The user may then
initiate a hot reset by calling the second ioctl.  We must be
careful that the user has ownership of all the affected devices
found via the first ioctl, so the second ioctl takes a list of file
descriptors for the VFIO groups affected by the reset.  Each group
must have IOMMU protection established for the ioctl to succeed.

Signed-off-by: Alex Williamson <alex.williamson@redhat.com>

2 files changed, 323 insertions, 1 deletions

diff --git a/drivers/vfio/pci/vfio_pci.c b/drivers/vfio/pci/vfio_pci.c
index cef6002acbd4..6ab71b9fcf8d 100644
--- a/drivers/vfio/pci/vfio_pci.c
+++ b/drivers/vfio/pci/vfio_pci.c
@@ -13,6 +13,7 @@
 
 #include <linux/device.h>
 #include <linux/eventfd.h>
+#include <linux/file.h>
 #include <linux/interrupt.h>
 #include <linux/iommu.h>
 #include <linux/module.h>
@@ -227,6 +228,110 @@ static int vfio_pci_get_irq_count(struct vfio_pci_device *vdev, int irq_type)
         return 0;
 }
 
+static int vfio_pci_count_devs(struct pci_dev *pdev, void *data)
+{
+        (*(int *)data)++;
+        return 0;
+}
+
+struct vfio_pci_fill_info {
+        int max;
+        int cur;
+        struct vfio_pci_dependent_device *devices;
+};
+
+static int vfio_pci_fill_devs(struct pci_dev *pdev, void *data)
+{
+        struct vfio_pci_fill_info *fill = data;
+        struct iommu_group *iommu_group;
+
+        if (fill->cur == fill->max)
+                return -EAGAIN; /* Something changed, try again */
+
+        iommu_group = iommu_group_get(&pdev->dev);
+        if (!iommu_group)
+                return -EPERM; /* Cannot reset non-isolated devices */
+
+        fill->devices[fill->cur].group_id = iommu_group_id(iommu_group);
+        fill->devices[fill->cur].segment = pci_domain_nr(pdev->bus);
+        fill->devices[fill->cur].bus = pdev->bus->number;
+        fill->devices[fill->cur].devfn = pdev->devfn;
+        fill->cur++;
+        iommu_group_put(iommu_group);
+        return 0;
+}
+
+struct vfio_pci_group_entry {
+        struct vfio_group *group;
+        int id;
+};
+
+struct vfio_pci_group_info {
+        int count;
+        struct vfio_pci_group_entry *groups;
+};
+
+static int vfio_pci_validate_devs(struct pci_dev *pdev, void *data)
+{
+        struct vfio_pci_group_info *info = data;
+        struct iommu_group *group;
+        int id, i;
+
+        group = iommu_group_get(&pdev->dev);
+        if (!group)
+                return -EPERM;
+
+        id = iommu_group_id(group);
+
+        for (i = 0; i < info->count; i++)
+                if (info->groups[i].id == id)
+                        break;
+
+        iommu_group_put(group);
+
+        return (i == info->count) ? -EINVAL : 0;
+}
+
+static bool vfio_pci_dev_below_slot(struct pci_dev *pdev, struct pci_slot *slot)
+{
+        for (; pdev; pdev = pdev->bus->self)
+                if (pdev->bus == slot->bus)
+                        return (pdev->slot == slot);
+        return false;
+}
+
+struct vfio_pci_walk_info {
+        int (*fn)(struct pci_dev *, void *data);
+        void *data;
+        struct pci_dev *pdev;
+        bool slot;
+        int ret;
+};
+
+static int vfio_pci_walk_wrapper(struct pci_dev *pdev, void *data)
+{
+        struct vfio_pci_walk_info *walk = data;
+
+        if (!walk->slot || vfio_pci_dev_below_slot(pdev, walk->pdev->slot))
+                walk->ret = walk->fn(pdev, walk->data);
+
+        return walk->ret;
+}
+
+static int vfio_pci_for_each_slot_or_bus(struct pci_dev *pdev,
+                                         int (*fn)(struct pci_dev *,
+                                                   void *data), void *data,
+                                         bool slot)
+{
+        struct vfio_pci_walk_info walk = {
+                .fn = fn, .data = data, .pdev = pdev, .slot = slot, .ret = 0,
+        };
+
+        pci_walk_bus(pdev->bus, vfio_pci_walk_wrapper, &walk);
+
+        return walk.ret;
+}
+
 static long vfio_pci_ioctl(void *device_data,
                            unsigned int cmd, unsigned long arg)
 {
@@ -407,10 +512,189 @@ static long vfio_pci_ioctl(void *device_data,
 
                 return ret;
 
-        } else if (cmd == VFIO_DEVICE_RESET)
+        } else if (cmd == VFIO_DEVICE_RESET) {
                 return vdev->reset_works ?
                         pci_reset_function(vdev->pdev) : -EINVAL;
 
+        } else if (cmd == VFIO_DEVICE_GET_PCI_HOT_RESET_INFO) {
+                struct vfio_pci_hot_reset_info hdr;
+                struct vfio_pci_fill_info fill = { 0 };
+                struct vfio_pci_dependent_device *devices = NULL;
+                bool slot = false;
+                int ret = 0;
+
+                minsz = offsetofend(struct vfio_pci_hot_reset_info, count);
+
+                if (copy_from_user(&hdr, (void __user *)arg, minsz))
+                        return -EFAULT;
+
+                if (hdr.argsz < minsz)
+                        return -EINVAL;
+
+                hdr.flags = 0;
+
+                /* Can we do a slot or bus reset or neither? */
+                if (!pci_probe_reset_slot(vdev->pdev->slot))
+                        slot = true;
+                else if (pci_probe_reset_bus(vdev->pdev->bus))
+                        return -ENODEV;
+
+                /* How many devices are affected? */
+                ret = vfio_pci_for_each_slot_or_bus(vdev->pdev,
+                                                    vfio_pci_count_devs,
+                                                    &fill.max, slot);
+                if (ret)
+                        return ret;
+
+                WARN_ON(!fill.max); /* Should always be at least one */
+
+                /*
+                 * If there's enough space, fill it now, otherwise return
+                 * -ENOSPC and the number of devices affected.
+                 */
+                if (hdr.argsz < sizeof(hdr) + (fill.max * sizeof(*devices))) {
+                        ret = -ENOSPC;
+                        hdr.count = fill.max;
+                        goto reset_info_exit;
+                }
+
+                devices = kcalloc(fill.max, sizeof(*devices), GFP_KERNEL);
+                if (!devices)
+                        return -ENOMEM;
+
+                fill.devices = devices;
+
+                ret = vfio_pci_for_each_slot_or_bus(vdev->pdev,
+                                                    vfio_pci_fill_devs,
+                                                    &fill, slot);
+
+                /*
+                 * If a device was removed between counting and filling,
+                 * we may come up short of fill.max.  If a device was
+                 * added, we'll have a return of -EAGAIN above.
+                 */
+                if (!ret)
+                        hdr.count = fill.cur;
+
+reset_info_exit:
+                if (copy_to_user((void __user *)arg, &hdr, minsz))
+                        ret = -EFAULT;
+
+                if (!ret) {
+                        if (copy_to_user((void __user *)(arg + minsz), devices,
+                                         hdr.count * sizeof(*devices)))
+                                ret = -EFAULT;
+                }
+