ch: implement host device management helper functions

We only want to support VFIO at this stage, but it wouldn't hurt to
implement as many functions as possible. They are mostly just wrappers
around Libvirt's hostdev infrastructure anyway.

Signed-off-by: Wei Liu <[email protected]>

Author: liuw

src/ch/ch_domain.h

@@ -25,6 +25,8 @@
 #include "virchrdev.h"
 #include "vircgroup.h"
 
+#define CH_DEV_VFIO "/dev/vfio/vfio"
+
 /* Give up waiting for mutex after 30 seconds */
 #define CH_JOB_WAIT_TIME (1000ull * 30)
 

src/ch/ch_hostdev.c

@@ -39,3 +39,320 @@
 #define VIR_FROM_THIS VIR_FROM_CH
 
 VIR_LOG_INIT("ch.ch_hostdev");
+
+bool
+chHostdevHostSupportsPassthroughVFIO(void)
+{
+    /* condition 1 - host has IOMMU */
+    if (!virHostHasIOMMU())
+        return false;
+
+    /* condition 2 - /dev/vfio/vfio exists */
+    if (!virFileExists(CH_DEV_VFIO))
+        return false;
+
+    return true;
+}
+
+bool
+chHostdevNeedsVFIO(const virDomainHostdevDef *hostdev)
+{
+    return virHostdevIsVFIODevice(hostdev) ||
+        virHostdevIsMdevDevice(hostdev);
+}
+
+static bool
+chHostdevPreparePCIDevicesCheckSupport(virDomainHostdevDefPtr *hostdevs,
+                                       size_t nhostdevs)
+{
+    bool supportsPassthroughVFIO = chHostdevHostSupportsPassthroughVFIO();
+    size_t i;
+
+    /* assign defaults for hostdev passthrough */
+    for (i = 0; i < nhostdevs; i++) {
+        virDomainHostdevDefPtr hostdev = hostdevs[i];
+        int *backend = &hostdev->source.subsys.u.pci.backend;
+
+        if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
+            continue;
+        if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
+            continue;
+
+        switch ((virDomainHostdevSubsysPCIBackendType)*backend) {
+        case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT:
+            if (supportsPassthroughVFIO) {
+                *backend = VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO;
+            } else {
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("host doesn't support passthrough of "
+                                 "host PCI devices"));
+                return false;
+            }
+
+            break;
+
+        case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO:
+            if (!supportsPassthroughVFIO) {
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("host doesn't support VFIO PCI passthrough"));
+                return false;
+            }
+            break;
+
+        case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_KVM:
+        case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_XEN:
+        case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_TYPE_LAST:
+            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s%s",
+                           _("host doesn't support passthrough: "),
+                           _(virDomainHostdevSubsysPCIBackendTypeToString(*backend)));
+            return false;
+        }
+    }
+
+    return true;
+}
+
+int
+chHostdevPrepareNVMeDisks(virCHDriverPtr driver,
+                          const char *name,
+                          virDomainDiskDefPtr *disks,
+                          size_t ndisks)
+{
+    return virHostdevPrepareNVMeDevices(driver->hostdevMgr,
+                                        CH_DRIVER_NAME,
+                                        name, disks, ndisks);
+}
+
+int
+chHostdevPreparePCIDevices(virCHDriverPtr driver,
+                           const char *name,
+                           const unsigned char *uuid,
+                           virDomainHostdevDefPtr *hostdevs,
+                           int nhostdevs,
+                           unsigned int flags)
+{
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+
+    if (!chHostdevPreparePCIDevicesCheckSupport(hostdevs, nhostdevs))
+        return -1;
+
+    return virHostdevPreparePCIDevices(hostdev_mgr, CH_DRIVER_NAME,
+                                       name, uuid, hostdevs,
+                                       nhostdevs, flags);
+}
+
+int
+chHostdevPrepareUSBDevices(virCHDriverPtr driver,
+                           const char *name,
+                           virDomainHostdevDefPtr *hostdevs,
+                           int nhostdevs,
+                           unsigned int flags)
+{
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+
+    return virHostdevPrepareUSBDevices(hostdev_mgr, CH_DRIVER_NAME, name,
+                                       hostdevs, nhostdevs, flags);
+}
+
+int
+chHostdevPrepareSCSIDevices(virCHDriverPtr driver,
+                            const char *name,
+                            virDomainHostdevDefPtr *hostdevs,
+                            int nhostdevs)
+{
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+
+    return virHostdevPrepareSCSIDevices(hostdev_mgr, CH_DRIVER_NAME,
+                                        name, hostdevs, nhostdevs);
+}
+
+int
+chHostdevPrepareSCSIVHostDevices(virCHDriverPtr driver,
+                                 const char *name,
+                                 virDomainHostdevDefPtr *hostdevs,
+                                 int nhostdevs)
+{
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+
+    return virHostdevPrepareSCSIVHostDevices(hostdev_mgr, CH_DRIVER_NAME,
+                                             name, hostdevs, nhostdevs);
+}
+
+int
+chHostdevPrepareMediatedDevices(virCHDriverPtr driver,
+                                const char *name,
+                                virDomainHostdevDefPtr *hostdevs,
+                                int nhostdevs)
+{
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+    bool supportsVFIO;
+    size_t i;
+
+    /* Checking for VFIO only is fine with mdev, as IOMMU isolation is achieved
+     * by the physical parent device.
+     */
+    supportsVFIO = virFileExists(CH_DEV_VFIO);
+
+    for (i = 0; i < nhostdevs; i++) {
+        if (virHostdevIsMdevDevice(hostdevs[i])) {
+            if (!supportsVFIO) {
+                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+                               _("Mediated host device assignment requires "
+                                 "VFIO support"));
+                return -1;
+            }
+            break;
+        }
+    }
+
+    return virHostdevPrepareMediatedDevices(hostdev_mgr, CH_DRIVER_NAME,
+                                            name, hostdevs, nhostdevs);
+}
+
+int
+chHostdevPrepareDomainDevices(virCHDriverPtr driver,
+                              virDomainDefPtr def,
+                              unsigned int flags)
+
+{
+    if (!def->nhostdevs && !def->ndisks)
+        return 0;
+
+    if (chHostdevPrepareNVMeDisks(driver, def->name, def->disks, def->ndisks) < 0)
+        return -1;
+
+    if (chHostdevPreparePCIDevices(driver, def->name, def->uuid,
+                                   def->hostdevs, def->nhostdevs,
+                                   flags) < 0)
+        return -1;
+
+    if (chHostdevPrepareUSBDevices(driver, def->name,
+                                   def->hostdevs, def->nhostdevs, flags) < 0)
+        return -1;
+
+    if (chHostdevPrepareSCSIDevices(driver, def->name,
+                                    def->hostdevs, def->nhostdevs) < 0)
+        return -1;
+
+    if (chHostdevPrepareSCSIVHostDevices(driver, def->name,
+                                         def->hostdevs, def->nhostdevs) < 0)
+        return -1;
+
+    if (chHostdevPrepareMediatedDevices(driver, def->name,
+                                        def->hostdevs, def->nhostdevs) < 0)
+        return -1;
+
+    return 0;
+}
+
+void
+chHostdevReAttachOneNVMeDisk(virCHDriverPtr driver,
+                             const char *name,
+                             virStorageSourcePtr src)
+{
+    virHostdevReAttachOneNVMeDevice(driver->hostdevMgr,
+                                    CH_DRIVER_NAME,
+                                    name,
+                                    src);
+}
+
+void
+chHostdevReAttachNVMeDisks(virCHDriverPtr driver,
+                           const char *name,
+                           virDomainDiskDefPtr *disks,
+                           size_t ndisks)
+{
+    virHostdevReAttachNVMeDevices(driver->hostdevMgr,
+                                  CH_DRIVER_NAME,
+                                  name, disks, ndisks);
+}
+
+void
+chHostdevReAttachPCIDevices(virCHDriverPtr driver,
+                            const char *name,
+                            virDomainHostdevDefPtr *hostdevs,
+                            int nhostdevs)
+{
+    virCHDriverConfigPtr cfg = virCHDriverGetConfig(driver);
+    const char *oldStateDir = cfg->stateDir;
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+
+    virHostdevReAttachPCIDevices(hostdev_mgr, CH_DRIVER_NAME, name,
+                                 hostdevs, nhostdevs, oldStateDir);
+
+    virObjectUnref(cfg);
+}
+
+void
+chHostdevReAttachUSBDevices(virCHDriverPtr driver,
+                            const char *name,
+                            virDomainHostdevDefPtr *hostdevs,
+                            int nhostdevs)
+{
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+
+    virHostdevReAttachUSBDevices(hostdev_mgr, CH_DRIVER_NAME,
+                                 name, hostdevs, nhostdevs);
+}
+
+void
+chHostdevReAttachSCSIDevices(virCHDriverPtr driver,
+                             const char *name,
+                             virDomainHostdevDefPtr *hostdevs,
+                             int nhostdevs)
+{
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+
+    virHostdevReAttachSCSIDevices(hostdev_mgr, CH_DRIVER_NAME,
+                                  name, hostdevs, nhostdevs);
+}
+
+void
+chHostdevReAttachSCSIVHostDevices(virCHDriverPtr driver,
+                                    const char *name,
+                                    virDomainHostdevDefPtr *hostdevs,
+                                    int nhostdevs)
+{
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+
+    virHostdevReAttachSCSIVHostDevices(hostdev_mgr, CH_DRIVER_NAME,
+                                       name, hostdevs, nhostdevs);
+}
+
+void
+chHostdevReAttachMediatedDevices(virCHDriverPtr driver,
+                                 const char *name,
+                                 virDomainHostdevDefPtr *hostdevs,
+                                 int nhostdevs)
+{
+    virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
+
+    virHostdevReAttachMediatedDevices(hostdev_mgr, CH_DRIVER_NAME,
+                                      name, hostdevs, nhostdevs);
+}
+
+void
+chHostdevReAttachDomainDevices(virCHDriverPtr driver,
+                               virDomainDefPtr def)
+{
+    if (!def->nhostdevs && !def->ndisks)
+        return;
+
+    chHostdevReAttachNVMeDisks(driver, def->name, def->disks,
+                               def->ndisks);
+
+    chHostdevReAttachPCIDevices(driver, def->name, def->hostdevs,
+                                def->nhostdevs);
+
+    chHostdevReAttachUSBDevices(driver, def->name, def->hostdevs,
+                                def->nhostdevs);
+
+    chHostdevReAttachSCSIDevices(driver, def->name, def->hostdevs,
+                                 def->nhostdevs);
+
+    chHostdevReAttachSCSIVHostDevices(driver, def->name, def->hostdevs,
+                                      def->nhostdevs);
+
+    chHostdevReAttachMediatedDevices(driver, def->name, def->hostdevs,
+                                     def->nhostdevs);
+}