diff --git a/SOURCES/libvirt-docs-update-description-of-virsh-nodedev-detach.patch b/SOURCES/libvirt-docs-update-description-of-virsh-nodedev-detach.patch new file mode 100644 index 0000000..15a6cac --- /dev/null +++ b/SOURCES/libvirt-docs-update-description-of-virsh-nodedev-detach.patch @@ -0,0 +1,53 @@ +From bbfcf18f504b0eb165c0bbfe2f34b4e20d11c355 Mon Sep 17 00:00:00 2001 +From: Laine Stump +Date: Fri, 25 Aug 2023 00:09:54 -0400 +Subject: [PATCH] docs: update description of virsh nodedev-detach --driver + option + +--driver can now be used to specify a specific driver to bind to the +device being detached from the host driver (e.g. vfio-pci-igbvf), not +just the *type* of driver (e.g. "vfio" or "xen", which are unnecessary +anyway, since they are implicit in which hypervisor driver is in use) + +Signed-off-by: Laine Stump +Reviewed-by: Michal Privoznik +--- + docs/manpages/virsh.rst | 25 +++++++++++++++++-------- + 1 file changed, 17 insertions(+), 8 deletions(-) + +diff --git a/docs/manpages/virsh.rst b/docs/manpages/virsh.rst +index 673812036d3..91e1d5de37d 100644 +--- a/docs/manpages/virsh.rst ++++ b/docs/manpages/virsh.rst +@@ -5388,14 +5388,23 @@ nodedev-detach + + nodedev-detach nodedev [--driver backend_driver] + +-Detach *nodedev* from the host, so that it can safely be used by +-guests via passthrough. This is reversed with +-``nodedev-reattach``, and is done automatically for managed devices. +- +-Different backend drivers expect the device to be bound to different +-dummy devices. For example, QEMU's "vfio" backend driver expects the +-device to be bound to vfio-pci. The *--driver* parameter can be used +-to specify the desired backend driver. ++Detach *nodedev* from the host driver and bind it to a special driver ++that provides the API needed by the hypervisor for assigning the ++device to a virtual machine (using in the domain XML ++definition). This is reversed with ``nodedev-reattach``, and is done ++automatically by the hypervisor driver for managed devices (those ++devices with "managed='yes'" in their XML definition). ++ ++Different hypervisors expect the device being assigned to be bound to ++different drivers. For example, QEMU's "vfio" backend requires the ++device to be bound to the driver "vfio-pci" or to a "VFIO variant" ++driver (this is a driver that supports the full API provided by ++vfio-pci, plus some other APIs to support things like live ++migration). The *--driver* parameter can be used to specify a ++particular driver (e.g. a device-specific VFIO variant driver) the ++device should be bound to. When *--driver* is omitted, the default ++driver for the hypervisor is used ("vfio-pci" for QEMU, "pciback" for ++Xen). + + + nodedev-dumpxml diff --git a/SOURCES/libvirt-node_device-support-binding-other-drivers-with-virNodeDevice.patch b/SOURCES/libvirt-node_device-support-binding-other-drivers-with-virNodeDevice.patch new file mode 100644 index 0000000..83d43b0 --- /dev/null +++ b/SOURCES/libvirt-node_device-support-binding-other-drivers-with-virNodeDevice.patch @@ -0,0 +1,178 @@ +From 24beaffec33efa3fa077d7b8596d97aa9a038a01 Mon Sep 17 00:00:00 2001 +From: Laine Stump +Date: Sun, 9 Jul 2023 00:37:45 -0400 +Subject: [PATCH] node_device: support binding other drivers with + virNodeDeviceDetachFlags() + +In the past, the only allowable values for the "driver" field of +virNodeDeviceDetachFlags() were "kvm" or "vfio" for the QEMU driver, +and "xen" for the libxl driver. Then "kvm" was deprecated and removed, +so the driver name became essentially irrelevant (because it is always +called via a particular hypervisor driver, and so the "xen" or "vfio" +can be (and almost always is) implied. + +With the advent of VFIO variant drivers, the ability to explicitly +specify a driver name once again becomes useful - it can be used to +name the exact VFIO driver that we want bound to the device in place +of vfio-pci, so this patch allows those other names to be passed down +the call chain, where the code in virpci.c can make use of them. + +The names "vfio", "kvm", and "xen" retain their special meaning, though: + + 1) because there may be some application or configuration that still + calls virNodeDeviceDetachFlags() with driverName="vfio", this + single value is substituted with the synonym of NULL, which means + "bind the default driver for this device and hypervisor". This + will currently result in the vfio-pci driver being bound to the + device. + + 2) in the case of the libxl driver, "xen" means to use the standard + driver used in the case of Xen ("pciback"). + + 3) "kvm" as a driver name always results in an error, as legacy KVM + device assignment was removed from the kernel around 10 years ago. + +Signed-off-by: Laine Stump +Reviewed-by: Michal Privoznik +--- + src/hypervisor/domain_driver.c | 11 ++++++----- + src/hypervisor/domain_driver.h | 2 ++ + src/libxl/libxl_driver.c | 3 ++- + src/qemu/qemu_driver.c | 33 +++++++++++++++++++-------------- + 4 files changed, 29 insertions(+), 20 deletions(-) + +diff --git a/src/hypervisor/domain_driver.c b/src/hypervisor/domain_driver.c +index a70f75f3ae8..d9469ad6f96 100644 +--- a/src/hypervisor/domain_driver.c ++++ b/src/hypervisor/domain_driver.c +@@ -462,6 +462,7 @@ virDomainDriverNodeDeviceReAttach(virNodeDevicePtr dev, + int + virDomainDriverNodeDeviceDetachFlags(virNodeDevicePtr dev, + virHostdevManager *hostdevMgr, ++ virPCIStubDriver driverType, + const char *driverName) + { + g_autoptr(virPCIDevice) pci = NULL; +@@ -471,8 +472,10 @@ virDomainDriverNodeDeviceDetachFlags(virNodeDevicePtr dev, + g_autoptr(virConnect) nodeconn = NULL; + g_autoptr(virNodeDevice) nodedev = NULL; + +- if (!driverName) ++ if (driverType == VIR_PCI_STUB_DRIVER_NONE) { ++ virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("driver type not set")); + return -1; ++ } + + if (!(nodeconn = virGetConnectNodeDev())) + return -1; +@@ -504,10 +507,8 @@ virDomainDriverNodeDeviceDetachFlags(virNodeDevicePtr dev, + if (!pci) + return -1; + +- if (STREQ(driverName, "vfio")) +- virPCIDeviceSetStubDriverType(pci, VIR_PCI_STUB_DRIVER_VFIO); +- else if (STREQ(driverName, "xen")) +- virPCIDeviceSetStubDriverType(pci, VIR_PCI_STUB_DRIVER_XEN); ++ virPCIDeviceSetStubDriverType(pci, driverType); ++ virPCIDeviceSetStubDriverName(pci, driverName); + + return virHostdevPCINodeDeviceDetach(hostdevMgr, pci); + } +diff --git a/src/hypervisor/domain_driver.h b/src/hypervisor/domain_driver.h +index 4241c869320..9942f58fda1 100644 +--- a/src/hypervisor/domain_driver.h ++++ b/src/hypervisor/domain_driver.h +@@ -22,6 +22,7 @@ + + #include "node_device_conf.h" + #include "virhostdev.h" ++#include "virpci.h" + + char * + virDomainDriverGenerateRootHash(const char *drivername, +@@ -58,6 +59,7 @@ int virDomainDriverNodeDeviceReAttach(virNodeDevicePtr dev, + + int virDomainDriverNodeDeviceDetachFlags(virNodeDevicePtr dev, + virHostdevManager *hostdevMgr, ++ virPCIStubDriver driverType, + const char *driverName); + + int virDomainDriverAddIOThreadCheck(virDomainDef *def, +diff --git a/src/libxl/libxl_driver.c b/src/libxl/libxl_driver.c +index 3d10f458508..079922dd32a 100644 +--- a/src/libxl/libxl_driver.c ++++ b/src/libxl/libxl_driver.c +@@ -5876,7 +5876,8 @@ libxlNodeDeviceDetachFlags(virNodeDevicePtr dev, + + /* virNodeDeviceDetachFlagsEnsureACL() is being called by + * virDomainDriverNodeDeviceDetachFlags() */ +- return virDomainDriverNodeDeviceDetachFlags(dev, hostdev_mgr, driverName); ++ return virDomainDriverNodeDeviceDetachFlags(dev, hostdev_mgr, ++ VIR_PCI_STUB_DRIVER_XEN, NULL); + } + + static int +diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c +index 73fa499e40d..5128b643642 100644 +--- a/src/qemu/qemu_driver.c ++++ b/src/qemu/qemu_driver.c +@@ -70,7 +70,6 @@ + #include "domain_driver.h" + #include "domain_postparse.h" + #include "domain_validate.h" +-#include "virpci.h" + #include "virpidfile.h" + #include "virprocess.h" + #include "libvirt_internal.h" +@@ -11407,24 +11406,28 @@ qemuNodeDeviceDetachFlags(virNodeDevicePtr dev, + + virCheckFlags(0, -1); + +- if (!driverName) +- driverName = "vfio"; +- +- /* Only the 'vfio' driver is supported and a special error message for +- * the previously supported 'kvm' driver is provided below. */ +- if (STRNEQ(driverName, "vfio") && STRNEQ(driverName, "kvm")) { +- virReportError(VIR_ERR_INVALID_ARG, +- _("unknown driver name '%1$s'"), driverName); +- return -1; +- } ++ /* For historical reasons, if driverName is "vfio", that is the ++ * same as NULL, i.e. the default vfio driver for this device ++ */ ++ if (STREQ_NULLABLE(driverName, "vfio")) ++ driverName = NULL; + +- if (STREQ(driverName, "kvm")) { ++ /* the "kvm" driver name was used a very long time ago to force ++ * "legacy KVM device assignment", which hasn't been supported in ++ * over 10 years. ++ */ ++ if (STREQ_NULLABLE(driverName, "kvm")) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", +- _("KVM device assignment is no longer " ++ _("'legacy KVM' device assignment is no longer " + "supported on this system")); + return -1; + } + ++ /* for any other driver, we can't know whether or not it is a VFIO ++ * driver until the device has been bound to it, so we will defer ++ * further validation until then. ++ */ ++ + if (!qemuHostdevHostSupportsPassthroughVFIO()) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("VFIO device assignment is currently not " +@@ -11434,7 +11437,9 @@ qemuNodeDeviceDetachFlags(virNodeDevicePtr dev, + + /* virNodeDeviceDetachFlagsEnsureACL() is being called by + * virDomainDriverNodeDeviceDetachFlags() */ +- return virDomainDriverNodeDeviceDetachFlags(dev, hostdev_mgr, driverName); ++ return virDomainDriverNodeDeviceDetachFlags(dev, hostdev_mgr, ++ VIR_PCI_STUB_DRIVER_VFIO, ++ driverName); + } + + static int diff --git a/SOURCES/libvirt-qemu-turn-two-multiline-log-messages-into-single-line.patch b/SOURCES/libvirt-qemu-turn-two-multiline-log-messages-into-single-line.patch new file mode 100644 index 0000000..ad9e9a0 --- /dev/null +++ b/SOURCES/libvirt-qemu-turn-two-multiline-log-messages-into-single-line.patch @@ -0,0 +1,38 @@ +From 10e8a518a05922d5592d1405054aed3195aebf06 Mon Sep 17 00:00:00 2001 +From: Laine Stump +Date: Fri, 18 Aug 2023 16:13:16 -0400 +Subject: [PATCH] qemu: turn two multiline log messages into single line + +Normally I wouldn't bother with a change like this, but I was touching +the function anyway, and wanted to leave it looking nice and tidy. + +Signed-off-by: Laine Stump +Reviewed-by: Michal Privoznik +--- + src/qemu/qemu_driver.c | 6 ++---- + 1 file changed, 2 insertions(+), 4 deletions(-) + +diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c +index 5128b643642..5db42f07533 100644 +--- a/src/qemu/qemu_driver.c ++++ b/src/qemu/qemu_driver.c +@@ -11418,8 +11418,7 @@ qemuNodeDeviceDetachFlags(virNodeDevicePtr dev, + */ + if (STREQ_NULLABLE(driverName, "kvm")) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", +- _("'legacy KVM' device assignment is no longer " +- "supported on this system")); ++ _("'legacy KVM' device assignment is no longer supported on this system")); + return -1; + } + +@@ -11430,8 +11429,7 @@ qemuNodeDeviceDetachFlags(virNodeDevicePtr dev, + + if (!qemuHostdevHostSupportsPassthroughVFIO()) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", +- _("VFIO device assignment is currently not " +- "supported on this system")); ++ _("VFIO device assignment is currently not supported on this system")); + return -1; + } + diff --git a/SOURCES/libvirt-util-add-stub-driver-name-to-virPCIDevice-object.patch b/SOURCES/libvirt-util-add-stub-driver-name-to-virPCIDevice-object.patch new file mode 100644 index 0000000..e30bca2 --- /dev/null +++ b/SOURCES/libvirt-util-add-stub-driver-name-to-virPCIDevice-object.patch @@ -0,0 +1,99 @@ +From 1bb961797153a92a40a3c517114e4920c65672d4 Mon Sep 17 00:00:00 2001 +From: Laine Stump +Date: Sat, 8 Jul 2023 22:20:39 -0400 +Subject: [PATCH] util: add stub driver name to virPCIDevice object + +There can be many different drivers that are of the type "VFIO", so +add the driver name to the object and allow getting/setting it. + +Signed-off-by: Laine Stump +Reviewed-by: Michal Privoznik +--- + src/libvirt_private.syms | 2 ++ + src/util/virpci.c | 17 +++++++++++++++++ + src/util/virpci.h | 3 +++ + 3 files changed, 22 insertions(+) + +diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms +index 190bebdd625..0ca63f09552 100644 +--- a/src/libvirt_private.syms ++++ b/src/libvirt_private.syms +@@ -3082,6 +3082,7 @@ virPCIDeviceGetManaged; + virPCIDeviceGetName; + virPCIDeviceGetRemoveSlot; + virPCIDeviceGetReprobe; ++virPCIDeviceGetStubDriverName; + virPCIDeviceGetStubDriverType; + virPCIDeviceGetUnbindFromStub; + virPCIDeviceGetUsedBy; +@@ -3108,6 +3109,7 @@ virPCIDeviceReset; + virPCIDeviceSetManaged; + virPCIDeviceSetRemoveSlot; + virPCIDeviceSetReprobe; ++virPCIDeviceSetStubDriverName; + virPCIDeviceSetStubDriverType; + virPCIDeviceSetUnbindFromStub; + virPCIDeviceSetUsedBy; +diff --git a/src/util/virpci.c b/src/util/virpci.c +index d86a81c2b1d..a53a51d55e2 100644 +--- a/src/util/virpci.c ++++ b/src/util/virpci.c +@@ -88,6 +88,7 @@ struct _virPCIDevice { + bool managed; + + virPCIStubDriver stubDriverType; ++ char *stubDriverName; /* if blank, use default for type */ + + /* used by reattach function */ + bool unbind_from_stub; +@@ -1508,6 +1509,7 @@ virPCIDeviceCopy(virPCIDevice *dev) + copy->path = g_strdup(dev->path); + copy->used_by_drvname = g_strdup(dev->used_by_drvname); + copy->used_by_domname = g_strdup(dev->used_by_domname); ++ copy->stubDriverName = g_strdup(dev->stubDriverName); + return copy; + } + +@@ -1522,6 +1524,7 @@ virPCIDeviceFree(virPCIDevice *dev) + g_free(dev->path); + g_free(dev->used_by_drvname); + g_free(dev->used_by_domname); ++ g_free(dev->stubDriverName); + g_free(dev); + } + +@@ -1581,6 +1584,20 @@ virPCIDeviceGetStubDriverType(virPCIDevice *dev) + return dev->stubDriverType; + } + ++void ++virPCIDeviceSetStubDriverName(virPCIDevice *dev, ++ const char *driverName) ++{ ++ g_free(dev->stubDriverName); ++ dev->stubDriverName = g_strdup(driverName); ++} ++ ++const char * ++virPCIDeviceGetStubDriverName(virPCIDevice *dev) ++{ ++ return dev->stubDriverName; ++} ++ + bool + virPCIDeviceGetUnbindFromStub(virPCIDevice *dev) + { +diff --git a/src/util/virpci.h b/src/util/virpci.h +index 485f535bc91..f8f98f39de7 100644 +--- a/src/util/virpci.h ++++ b/src/util/virpci.h +@@ -137,6 +137,9 @@ bool virPCIDeviceGetManaged(virPCIDevice *dev); + void virPCIDeviceSetStubDriverType(virPCIDevice *dev, + virPCIStubDriver driverType); + virPCIStubDriver virPCIDeviceGetStubDriverType(virPCIDevice *dev); ++void virPCIDeviceSetStubDriverName(virPCIDevice *dev, ++ const char *driverName); ++const char *virPCIDeviceGetStubDriverName(virPCIDevice *dev); + virPCIDeviceAddress *virPCIDeviceGetAddress(virPCIDevice *dev); + int virPCIDeviceSetUsedBy(virPCIDevice *dev, + const char *drv_name, diff --git a/SOURCES/libvirt-util-honor-stubDriverName-when-probing.patch b/SOURCES/libvirt-util-honor-stubDriverName-when-probing.patch new file mode 100644 index 0000000..cb91971 --- /dev/null +++ b/SOURCES/libvirt-util-honor-stubDriverName-when-probing.patch @@ -0,0 +1,40 @@ +From 928296b044647fd3cbe409db6903afc791863a90 Mon Sep 17 00:00:00 2001 +From: Laine Stump +Date: Sat, 8 Jul 2023 23:05:44 -0400 +Subject: [PATCH] util: honor stubDriverName when probing/binding stub driver + for a device + +Signed-off-by: Laine Stump +Reviewed-by: Michal Privoznik +--- + src/util/virpci.c | 9 ++++++--- + 1 file changed, 6 insertions(+), 3 deletions(-) + +diff --git a/src/util/virpci.c b/src/util/virpci.c +index f1936795da7..1158e468bf9 100644 +--- a/src/util/virpci.c ++++ b/src/util/virpci.c +@@ -1290,17 +1290,20 @@ virPCIDeviceUnbindFromStub(virPCIDevice *dev) + static int + virPCIDeviceBindToStub(virPCIDevice *dev) + { +- const char *stubDriverName; ++ const char *stubDriverName = dev->stubDriverName; + g_autofree char *stubDriverPath = NULL; + g_autofree char *driverLink = NULL; + +- /* Check the device is configured to use one of the known stub drivers */ ++ + if (dev->stubDriverType == VIR_PCI_STUB_DRIVER_NONE) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("No stub driver configured for PCI device %1$s"), + dev->name); + return -1; +- } else if (!(stubDriverName = virPCIStubDriverTypeToString(dev->stubDriverType))) { ++ } ++ ++ if (!stubDriverName ++ && !(stubDriverName = virPCIStubDriverTypeToString(dev->stubDriverType))) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Unknown stub driver configured for PCI device %1$s"), + dev->name); diff --git a/SOURCES/libvirt-util-permit-existing-binding-to-VFIO-variant-driver.patch b/SOURCES/libvirt-util-permit-existing-binding-to-VFIO-variant-driver.patch new file mode 100644 index 0000000..6eb3f1e --- /dev/null +++ b/SOURCES/libvirt-util-permit-existing-binding-to-VFIO-variant-driver.patch @@ -0,0 +1,250 @@ +From 6ce071f6097d9e96892d5a6c7bd3040f43cc925b Mon Sep 17 00:00:00 2001 +From: Laine Stump +Date: Fri, 2 Jun 2023 14:34:51 -0400 +Subject: [PATCH] util: permit existing binding to VFIO variant driver + +Before a PCI device can be assigned to a guest with VFIO, that device +must be bound to the vfio-pci driver rather than to the device's +normal host driver. The vfio-pci driver provides APIs that permit QEMU +to perform all the necessary operations to make the device accessible +to the guest. + +In the past vfio-pci was the only driver that supplied these APIs, but +there are now vendor/device-specific "VFIO variant" drivers that +provide the basic vfio-pci driver functionality/API while adding +support for device-specific operations (for example these +device-specific drivers may support live migration of certain +devices). All that is needed to make this functionality available is +to bind the vendor-specific "VFIO variant" driver to the device +(rather than the generic vfio-pci driver, which will continue to work, +just without the extra functionality). + +But until now libvirt has required that all PCI devices being assigned +to a guest with VFIO specifically have the "vfio-pci" driver bound to +the device. So even if the user manually binds a shiny new +vendor-specific VFIO variant driver to the device (and puts +"managed='no'" in the config to prevent libvirt from changing the +binding), libvirt will just fail during startup of the guest (or +during hotplug) because the driver bound to the device isn't exactly +"vfio-pci". + +Beginning with kernel 6.1, it's possible to determine from the sysfs +directory for a device whether the currently-bound driver is the +vfio-pci driver or a VFIO variant - the device directory will have a +subdirectory called "vfio-dev". We can use that to appropriately widen +the list of drivers that libvirt will allow for VFIO device +assignment. + +This patch doesn't remove the explicit check for the exact "vfio-pci" +driver (since that would cause systems with pre-6.1 kernels to behave +incorrectly), but adds an additional check for the vfio-dev directory, +so that any VFIO variant driver is acceptable for libvirt to continue +setting up for VFIO device assignment. + +Signed-off-by: Laine Stump +Reviewed-by: Michal Privoznik +--- + src/hypervisor/virhostdev.c | 28 +++++-------- + src/libvirt_private.syms | 1 + + src/util/virpci.c | 78 ++++++++++++++++++++++++++++++++++--- + src/util/virpci.h | 3 ++ + 4 files changed, 87 insertions(+), 23 deletions(-) + +diff --git a/src/hypervisor/virhostdev.c b/src/hypervisor/virhostdev.c +index 244f057c6ce..b95d6bf3d61 100644 +--- a/src/hypervisor/virhostdev.c ++++ b/src/hypervisor/virhostdev.c +@@ -743,9 +743,8 @@ virHostdevPreparePCIDevicesImpl(virHostdevManager *mgr, + mgr->inactivePCIHostdevs) < 0) + goto reattachdevs; + } else { +- g_autofree char *driverPath = NULL; +- g_autofree char *driverName = NULL; +- int stub; ++ g_autofree char *drvName = NULL; ++ virPCIStubDriver drvType; + + /* Unmanaged devices should already have been marked as + * inactive: if that's the case, we can simply move on */ +@@ -765,19 +764,17 @@ virHostdevPreparePCIDevicesImpl(virHostdevManager *mgr, + * information about active / inactive device across + * daemon restarts has been implemented */ + +- if (virPCIDeviceGetCurrentDriverPathAndName(pci, &driverPath, +- &driverName) < 0) { ++ if (virPCIDeviceGetCurrentDriverNameAndType(pci, &drvName, ++ &drvType) < 0) { + goto reattachdevs; + } + +- stub = virPCIStubDriverTypeFromString(driverName); +- +- if (stub > VIR_PCI_STUB_DRIVER_NONE && +- stub < VIR_PCI_STUB_DRIVER_LAST) { ++ if (drvType > VIR_PCI_STUB_DRIVER_NONE) { + + /* The device is bound to a known stub driver: store this + * information and add a copy to the inactive list */ +- virPCIDeviceSetStubDriverType(pci, stub); ++ virPCIDeviceSetStubDriverType(pci, drvType); ++ virPCIDeviceSetStubDriverName(pci, drvName); + + VIR_DEBUG("Adding PCI device %s to inactive list", + virPCIDeviceGetName(pci)); +@@ -2291,18 +2288,13 @@ virHostdevPrepareOneNVMeDevice(virHostdevManager *hostdev_mgr, + /* Let's check if all PCI devices are NVMe disks. */ + for (i = 0; i < virPCIDeviceListCount(pciDevices); i++) { + virPCIDevice *pci = virPCIDeviceListGet(pciDevices, i); +- g_autofree char *drvPath = NULL; + g_autofree char *drvName = NULL; +- int stub = VIR_PCI_STUB_DRIVER_NONE; ++ virPCIStubDriver drvType; + +- if (virPCIDeviceGetCurrentDriverPathAndName(pci, &drvPath, &drvName) < 0) ++ if (virPCIDeviceGetCurrentDriverNameAndType(pci, &drvName, &drvType) < 0) + goto cleanup; + +- if (drvName) +- stub = virPCIStubDriverTypeFromString(drvName); +- +- if (stub == VIR_PCI_STUB_DRIVER_VFIO || +- STREQ_NULLABLE(drvName, "nvme")) ++ if (drvType == VIR_PCI_STUB_DRIVER_VFIO || STREQ_NULLABLE(drvName, "nvme")) + continue; + + VIR_WARN("Suspicious NVMe disk assignment. PCI device " +diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms +index cc564928170..ab049b38584 100644 +--- a/src/libvirt_private.syms ++++ b/src/libvirt_private.syms +@@ -3074,6 +3074,7 @@ virPCIDeviceFileIterate; + virPCIDeviceFree; + virPCIDeviceGetAddress; + virPCIDeviceGetConfigPath; ++virPCIDeviceGetCurrentDriverNameAndType; + virPCIDeviceGetCurrentDriverPathAndName; + virPCIDeviceGetIOMMUGroupDev; + virPCIDeviceGetIOMMUGroupList; +diff --git a/src/util/virpci.c b/src/util/virpci.c +index e6f7554b232..253ddccabdd 100644 +--- a/src/util/virpci.c ++++ b/src/util/virpci.c +@@ -280,6 +280,73 @@ virPCIDeviceGetCurrentDriverPathAndName(virPCIDevice *dev, + } + + ++/** ++ * virPCIDeviceGetCurrentDriverNameAndType: ++ * @dev: virPCIDevice object to examine ++ * @drvName: returns name of driver bound to this device (if any) ++ * @drvType: returns type of driver if it is a known stub driver type ++ * ++ * Find the name of the driver bound to @dev (if any) and the type of ++ * the driver if it is a known/recognized "stub" driver (based on the ++ * driver name). ++ * ++ * There are vfio "variant" drivers that provide all the basic ++ * functionality of the standard vfio-pci driver as well as additional ++ * stuff. As of kernel 6.1, the vfio-pci driver and all vfio variant ++ * drivers can be identified (once the driver has been bound to a ++ * device) by looking for the subdirectory "vfio-dev" in the device's ++ * sysfs directory; for example, if the directory ++ * /sys/bus/pci/devices/0000:04:11.4/vfio-dev exists, then the driver ++ * that is currently bound to PCI device 0000:04:11.4 is either ++ * vfio-pci, or a vfio-pci variant driver. ++ * ++ * Return 0 on success, -1 on failure. If -1 is returned, then an error ++ * message has been logged. ++ */ ++int ++virPCIDeviceGetCurrentDriverNameAndType(virPCIDevice *dev, ++ char **drvName, ++ virPCIStubDriver *drvType) ++{ ++ g_autofree char *drvPath = NULL; ++ g_autofree char *vfioDevDir = NULL; ++ int tmpType; ++ ++ if (virPCIDeviceGetCurrentDriverPathAndName(dev, &drvPath, drvName) < 0) ++ return -1; ++ ++ if (!*drvName) { ++ *drvType = VIR_PCI_STUB_DRIVER_NONE; ++ return 0; ++ } ++ ++ tmpType = virPCIStubDriverTypeFromString(*drvName); ++ ++ if (tmpType > VIR_PCI_STUB_DRIVER_NONE) { ++ *drvType = tmpType; ++ return 0; /* exact match of a known driver name (or no name) */ ++ } ++ ++ /* If the sysfs directory of this device contains a directory ++ * named "vfio-dev" then the currently-bound driver is a vfio ++ * variant driver. ++ */ ++ ++ vfioDevDir = virPCIFile(dev->name, "vfio-dev"); ++ ++ if (virFileIsDir(vfioDevDir)) { ++ VIR_DEBUG("Driver %s is a vfio_pci driver", *drvName); ++ *drvType = VIR_PCI_STUB_DRIVER_VFIO; ++ } else { ++ VIR_DEBUG("Driver %s is NOT a vfio_pci driver, or kernel is too old", ++ *drvName); ++ *drvType = VIR_PCI_STUB_DRIVER_NONE; ++ } ++ ++ return 0; ++} ++ ++ + static int + virPCIDeviceConfigOpenInternal(virPCIDevice *dev, bool readonly, bool fatal) + { +@@ -1007,8 +1074,8 @@ virPCIDeviceReset(virPCIDevice *dev, + virPCIDeviceList *activeDevs, + virPCIDeviceList *inactiveDevs) + { +- g_autofree char *drvPath = NULL; + g_autofree char *drvName = NULL; ++ virPCIStubDriver drvType; + int ret = -1; + int fd = -1; + int hdrType = -1; +@@ -1034,15 +1101,16 @@ virPCIDeviceReset(virPCIDevice *dev, + * reset it whenever appropriate, so doing it ourselves would just + * be redundant. + */ +- if (virPCIDeviceGetCurrentDriverPathAndName(dev, &drvPath, &drvName) < 0) ++ if (virPCIDeviceGetCurrentDriverNameAndType(dev, &drvName, &drvType) < 0) + goto cleanup; + +- if (virPCIStubDriverTypeFromString(drvName) == VIR_PCI_STUB_DRIVER_VFIO) { +- VIR_DEBUG("Device %s is bound to vfio-pci - skip reset", +- dev->name); ++ if (drvType == VIR_PCI_STUB_DRIVER_VFIO) { ++ ++ VIR_DEBUG("Device %s is bound to %s - skip reset", dev->name, drvName); + ret = 0; + goto cleanup; + } ++ + VIR_DEBUG("Resetting device %s", dev->name); + + if ((fd = virPCIDeviceConfigOpenWrite(dev)) < 0) +diff --git a/src/util/virpci.h b/src/util/virpci.h +index 19c910202a2..faca6cf6f99 100644 +--- a/src/util/virpci.h ++++ b/src/util/virpci.h +@@ -283,6 +283,9 @@ int virPCIDeviceRebind(virPCIDevice *dev); + int virPCIDeviceGetCurrentDriverPathAndName(virPCIDevice *dev, + char **path, + char **name); ++int virPCIDeviceGetCurrentDriverNameAndType(virPCIDevice *dev, ++ char **drvName, ++ virPCIStubDriver *drvType); + + int virPCIDeviceIsPCIExpress(virPCIDevice *dev); + int virPCIDeviceHasPCIExpressLink(virPCIDevice *dev); diff --git a/SOURCES/libvirt-util-probe-stub-driver-from-within-function-that-binds-to-stub-driver.patch b/SOURCES/libvirt-util-probe-stub-driver-from-within-function-that-binds-to-stub-driver.patch new file mode 100644 index 0000000..53b50ef --- /dev/null +++ b/SOURCES/libvirt-util-probe-stub-driver-from-within-function-that-binds-to-stub-driver.patch @@ -0,0 +1,107 @@ +From 2d9c9445b9cc093c870f101eb884ddeac3ae40f7 Mon Sep 17 00:00:00 2001 +From: Laine Stump +Date: Sun, 9 Jul 2023 15:00:26 -0400 +Subject: [PATCH] util: probe stub driver from within function that binds to + stub driver + +virPCIProbeStubDriver() and virPCIDeviceBindToStub() both have +very similar code that locally sets a driver name (based on +stubDriverType). These two functions are each also called in just one +place (virPCIDeviceDetach()), with just a small bit of validation code +in between. + +To eliminate the "duplicated" code (which is going to be expanded +slightly in upcoming patches to support manually or automatically +picking a VFIO variant driver), this patch modifies +virPCIProbeStubDriver() to take the driver name as an argument +(rather than the virPCIDevice object), and calls it from within +virPCIDeviceBindToStub() (rather than from that function's caller), +using the driverName it has just figured out with the +now-not-duplicated code. + +(NB: Since it could be used to probe *any* driver module, the name is +changed to virPCIProbeDriver()). + +Signed-off-by: Laine Stump +Reviewed-by: Michal Privoznik +--- + src/util/virpci.c | 33 ++++++++++++--------------------- + 1 file changed, 12 insertions(+), 21 deletions(-) + +diff --git a/src/util/virpci.c b/src/util/virpci.c +index 253ddccabdd..f1936795da7 100644 +--- a/src/util/virpci.c ++++ b/src/util/virpci.c +@@ -1154,28 +1154,19 @@ virPCIDeviceReset(virPCIDevice *dev, + + + static int +-virPCIProbeStubDriver(virPCIStubDriver driver) ++virPCIProbeDriver(const char *driverName) + { +- const char *drvname = NULL; + g_autofree char *drvpath = NULL; + g_autofree char *errbuf = NULL; + +- if (driver == VIR_PCI_STUB_DRIVER_NONE || +- !(drvname = virPCIStubDriverTypeToString(driver))) { +- virReportError(VIR_ERR_INTERNAL_ERROR, +- "%s", +- _("Attempting to use unknown stub driver")); +- return -1; +- } +- +- drvpath = virPCIDriverDir(drvname); ++ drvpath = virPCIDriverDir(driverName); + + /* driver previously loaded, return */ + if (virFileExists(drvpath)) + return 0; + +- if ((errbuf = virKModLoad(drvname))) { +- VIR_WARN("failed to load driver %s: %s", drvname, errbuf); ++ if ((errbuf = virKModLoad(driverName))) { ++ VIR_WARN("failed to load driver %s: %s", driverName, errbuf); + goto cleanup; + } + +@@ -1187,14 +1178,14 @@ virPCIProbeStubDriver(virPCIStubDriver driver) + /* If we know failure was because of admin config, let's report that; + * otherwise, report a more generic failure message + */ +- if (virKModIsProhibited(drvname)) { ++ if (virKModIsProhibited(driverName)) { + virReportError(VIR_ERR_INTERNAL_ERROR, +- _("Failed to load PCI stub module %1$s: administratively prohibited"), +- drvname); ++ _("Failed to load PCI driver module %1$s: administratively prohibited"), ++ driverName); + } else { + virReportError(VIR_ERR_INTERNAL_ERROR, +- _("Failed to load PCI stub module %1$s"), +- drvname); ++ _("Failed to load PCI driver module %1$s"), ++ driverName); + } + + return -1; +@@ -1316,6 +1307,9 @@ virPCIDeviceBindToStub(virPCIDevice *dev) + return -1; + } + ++ if (virPCIProbeDriver(stubDriverName) < 0) ++ return -1; ++ + stubDriverPath = virPCIDriverDir(stubDriverName); + driverLink = virPCIFile(dev->name, "driver"); + +@@ -1359,9 +1353,6 @@ virPCIDeviceDetach(virPCIDevice *dev, + virPCIDeviceList *activeDevs, + virPCIDeviceList *inactiveDevs) + { +- if (virPCIProbeStubDriver(dev->stubDriverType) < 0) +- return -1; +- + if (activeDevs && virPCIDeviceListFind(activeDevs, &dev->address)) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Not detaching active device %1$s"), dev->name); diff --git a/SOURCES/libvirt-util-rename-virPCIDeviceGetDriverPathAndName.patch b/SOURCES/libvirt-util-rename-virPCIDeviceGetDriverPathAndName.patch new file mode 100644 index 0000000..3c1a070 --- /dev/null +++ b/SOURCES/libvirt-util-rename-virPCIDeviceGetDriverPathAndName.patch @@ -0,0 +1,132 @@ +From 222b66974e8256965c089fb0f244dc1e01f708e7 Mon Sep 17 00:00:00 2001 +From: Laine Stump +Date: Sat, 8 Jul 2023 23:12:09 -0400 +Subject: [PATCH] util: rename virPCIDeviceGetDriverPathAndName + +Instead, call it virPCIDeviceGetCurrentDriverPathAndName() to avoid +confusion with the device name that is stored in the virPCIDevice +object - that one is not necessarily the name of the current driver +for the device, but could instead be the driver that we want to be +bound to the device in the future. + +Signed-off-by: Laine Stump +Reviewed-by: Michal Privoznik +--- + src/hypervisor/virhostdev.c | 7 ++++--- + src/libvirt_private.syms | 2 +- + src/util/virpci.c | 10 ++++++---- + src/util/virpci.h | 6 +++--- + tests/virpcitest.c | 2 +- + 5 files changed, 15 insertions(+), 12 deletions(-) + +diff --git a/src/hypervisor/virhostdev.c b/src/hypervisor/virhostdev.c +index c437ca9d22d..244f057c6ce 100644 +--- a/src/hypervisor/virhostdev.c ++++ b/src/hypervisor/virhostdev.c +@@ -765,9 +765,10 @@ virHostdevPreparePCIDevicesImpl(virHostdevManager *mgr, + * information about active / inactive device across + * daemon restarts has been implemented */ + +- if (virPCIDeviceGetDriverPathAndName(pci, +- &driverPath, &driverName) < 0) ++ if (virPCIDeviceGetCurrentDriverPathAndName(pci, &driverPath, ++ &driverName) < 0) { + goto reattachdevs; ++ } + + stub = virPCIStubDriverTypeFromString(driverName); + +@@ -2294,7 +2295,7 @@ virHostdevPrepareOneNVMeDevice(virHostdevManager *hostdev_mgr, + g_autofree char *drvName = NULL; + int stub = VIR_PCI_STUB_DRIVER_NONE; + +- if (virPCIDeviceGetDriverPathAndName(pci, &drvPath, &drvName) < 0) ++ if (virPCIDeviceGetCurrentDriverPathAndName(pci, &drvPath, &drvName) < 0) + goto cleanup; + + if (drvName) +diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms +index 0ca63f09552..cc564928170 100644 +--- a/src/libvirt_private.syms ++++ b/src/libvirt_private.syms +@@ -3074,7 +3074,7 @@ virPCIDeviceFileIterate; + virPCIDeviceFree; + virPCIDeviceGetAddress; + virPCIDeviceGetConfigPath; +-virPCIDeviceGetDriverPathAndName; ++virPCIDeviceGetCurrentDriverPathAndName; + virPCIDeviceGetIOMMUGroupDev; + virPCIDeviceGetIOMMUGroupList; + virPCIDeviceGetLinkCapSta; +diff --git a/src/util/virpci.c b/src/util/virpci.c +index a53a51d55e2..e6f7554b232 100644 +--- a/src/util/virpci.c ++++ b/src/util/virpci.c +@@ -228,7 +228,7 @@ virPCIFile(const char *device, const char *file) + } + + +-/* virPCIDeviceGetDriverPathAndName - put the path to the driver ++/* virPCIDeviceGetCurrentDriverPathAndName - put the path to the driver + * directory of the driver in use for this device in @path and the + * name of the driver in @name. Both could be NULL if it's not bound + * to any driver. +@@ -236,7 +236,9 @@ virPCIFile(const char *device, const char *file) + * Return 0 for success, -1 for error. + */ + int +-virPCIDeviceGetDriverPathAndName(virPCIDevice *dev, char **path, char **name) ++virPCIDeviceGetCurrentDriverPathAndName(virPCIDevice *dev, ++ char **path, ++ char **name) + { + int ret = -1; + g_autofree char *drvlink = NULL; +@@ -1032,7 +1034,7 @@ virPCIDeviceReset(virPCIDevice *dev, + * reset it whenever appropriate, so doing it ourselves would just + * be redundant. + */ +- if (virPCIDeviceGetDriverPathAndName(dev, &drvPath, &drvName) < 0) ++ if (virPCIDeviceGetCurrentDriverPathAndName(dev, &drvPath, &drvName) < 0) + goto cleanup; + + if (virPCIStubDriverTypeFromString(drvName) == VIR_PCI_STUB_DRIVER_VFIO) { +@@ -1137,7 +1139,7 @@ virPCIDeviceUnbind(virPCIDevice *dev) + g_autofree char *drvpath = NULL; + g_autofree char *driver = NULL; + +- if (virPCIDeviceGetDriverPathAndName(dev, &drvpath, &driver) < 0) ++ if (virPCIDeviceGetCurrentDriverPathAndName(dev, &drvpath, &driver) < 0) + return -1; + + if (!driver) +diff --git a/src/util/virpci.h b/src/util/virpci.h +index f8f98f39de7..19c910202a2 100644 +--- a/src/util/virpci.h ++++ b/src/util/virpci.h +@@ -280,9 +280,9 @@ virPCIVPDResource * virPCIDeviceGetVPD(virPCIDevice *dev); + + int virPCIDeviceUnbind(virPCIDevice *dev); + int virPCIDeviceRebind(virPCIDevice *dev); +-int virPCIDeviceGetDriverPathAndName(virPCIDevice *dev, +- char **path, +- char **name); ++int virPCIDeviceGetCurrentDriverPathAndName(virPCIDevice *dev, ++ char **path, ++ char **name); + + int virPCIDeviceIsPCIExpress(virPCIDevice *dev); + int virPCIDeviceHasPCIExpressLink(virPCIDevice *dev); +diff --git a/tests/virpcitest.c b/tests/virpcitest.c +index 92cc8c07c6f..d69a1b51183 100644 +--- a/tests/virpcitest.c ++++ b/tests/virpcitest.c +@@ -37,7 +37,7 @@ testVirPCIDeviceCheckDriver(virPCIDevice *dev, const char *expected) + g_autofree char *path = NULL; + g_autofree char *driver = NULL; + +- if (virPCIDeviceGetDriverPathAndName(dev, &path, &driver) < 0) ++ if (virPCIDeviceGetCurrentDriverPathAndName(dev, &path, &driver) < 0) + return -1; + + if (STRNEQ_NULLABLE(driver, expected)) { diff --git a/SOURCES/libvirt-util-use-stubDriverType-instead-of-just-stubDriver.patch b/SOURCES/libvirt-util-use-stubDriverType-instead-of-just-stubDriver.patch new file mode 100644 index 0000000..647e063 --- /dev/null +++ b/SOURCES/libvirt-util-use-stubDriverType-instead-of-just-stubDriver.patch @@ -0,0 +1,251 @@ +From cd2843f5463d93eee00fab31fe259ad1b5b27a27 Mon Sep 17 00:00:00 2001 +From: Laine Stump +Date: Sat, 8 Jul 2023 22:11:06 -0400 +Subject: [PATCH] util: use "stubDriverType" instead of just "stubDriver" + +In the past we just kept track of the type of the "stub driver" (the +driver that is bound to a device in order to assign it to a +guest). The next commit will add a stubDriverName to go along with +type, so lets use stubDriverType for the existing enum to make it +easier to keep track of whether we're talking about the name or the +type. + +Signed-off-by: Laine Stump +Reviewed-by: Michal Privoznik +--- + src/hypervisor/domain_driver.c | 4 ++-- + src/hypervisor/virhostdev.c | 8 ++++---- + src/libvirt_private.syms | 4 ++-- + src/util/virnvme.c | 2 +- + src/util/virpci.c | 23 ++++++++++++----------- + src/util/virpci.h | 6 +++--- + tests/virhostdevtest.c | 2 +- + tests/virpcitest.c | 8 ++++---- + 8 files changed, 29 insertions(+), 28 deletions(-) + +diff --git a/src/hypervisor/domain_driver.c b/src/hypervisor/domain_driver.c +index 66e09ffb04f..a70f75f3ae8 100644 +--- a/src/hypervisor/domain_driver.c ++++ b/src/hypervisor/domain_driver.c +@@ -505,9 +505,9 @@ virDomainDriverNodeDeviceDetachFlags(virNodeDevicePtr dev, + return -1; + + if (STREQ(driverName, "vfio")) +- virPCIDeviceSetStubDriver(pci, VIR_PCI_STUB_DRIVER_VFIO); ++ virPCIDeviceSetStubDriverType(pci, VIR_PCI_STUB_DRIVER_VFIO); + else if (STREQ(driverName, "xen")) +- virPCIDeviceSetStubDriver(pci, VIR_PCI_STUB_DRIVER_XEN); ++ virPCIDeviceSetStubDriverType(pci, VIR_PCI_STUB_DRIVER_XEN); + + return virHostdevPCINodeDeviceDetach(hostdevMgr, pci); + } +diff --git a/src/hypervisor/virhostdev.c b/src/hypervisor/virhostdev.c +index eac34747836..c437ca9d22d 100644 +--- a/src/hypervisor/virhostdev.c ++++ b/src/hypervisor/virhostdev.c +@@ -244,9 +244,9 @@ virHostdevGetPCIHostDevice(const virDomainHostdevDef *hostdev, + virPCIDeviceSetManaged(actual, hostdev->managed); + + if (pcisrc->backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO) { +- virPCIDeviceSetStubDriver(actual, VIR_PCI_STUB_DRIVER_VFIO); ++ virPCIDeviceSetStubDriverType(actual, VIR_PCI_STUB_DRIVER_VFIO); + } else if (pcisrc->backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_XEN) { +- virPCIDeviceSetStubDriver(actual, VIR_PCI_STUB_DRIVER_XEN); ++ virPCIDeviceSetStubDriverType(actual, VIR_PCI_STUB_DRIVER_XEN); + } else { + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, + _("pci backend driver '%1$s' is not supported"), +@@ -679,7 +679,7 @@ virHostdevPreparePCIDevicesImpl(virHostdevManager *mgr, + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevice *pci = virPCIDeviceListGet(pcidevs, i); + bool strict_acs_check = !!(flags & VIR_HOSTDEV_STRICT_ACS_CHECK); +- bool usesVFIO = (virPCIDeviceGetStubDriver(pci) == VIR_PCI_STUB_DRIVER_VFIO); ++ bool usesVFIO = (virPCIDeviceGetStubDriverType(pci) == VIR_PCI_STUB_DRIVER_VFIO); + struct virHostdevIsPCINodeDeviceUsedData data = {mgr, drv_name, dom_name, false}; + int hdrType = -1; + +@@ -776,7 +776,7 @@ virHostdevPreparePCIDevicesImpl(virHostdevManager *mgr, + + /* The device is bound to a known stub driver: store this + * information and add a copy to the inactive list */ +- virPCIDeviceSetStubDriver(pci, stub); ++ virPCIDeviceSetStubDriverType(pci, stub); + + VIR_DEBUG("Adding PCI device %s to inactive list", + virPCIDeviceGetName(pci)); +diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms +index 00cf32d49e8..190bebdd625 100644 +--- a/src/libvirt_private.syms ++++ b/src/libvirt_private.syms +@@ -3082,7 +3082,7 @@ virPCIDeviceGetManaged; + virPCIDeviceGetName; + virPCIDeviceGetRemoveSlot; + virPCIDeviceGetReprobe; +-virPCIDeviceGetStubDriver; ++virPCIDeviceGetStubDriverType; + virPCIDeviceGetUnbindFromStub; + virPCIDeviceGetUsedBy; + virPCIDeviceGetVPD; +@@ -3108,7 +3108,7 @@ virPCIDeviceReset; + virPCIDeviceSetManaged; + virPCIDeviceSetRemoveSlot; + virPCIDeviceSetReprobe; +-virPCIDeviceSetStubDriver; ++virPCIDeviceSetStubDriverType; + virPCIDeviceSetUnbindFromStub; + virPCIDeviceSetUsedBy; + virPCIDeviceUnbind; +diff --git a/src/util/virnvme.c b/src/util/virnvme.c +index f7f8dc5ea91..37333d515b4 100644 +--- a/src/util/virnvme.c ++++ b/src/util/virnvme.c +@@ -292,7 +292,7 @@ virNVMeDeviceCreatePCIDevice(const virNVMeDevice *nvme) + return NULL; + + /* NVMe devices must be bound to vfio */ +- virPCIDeviceSetStubDriver(pci, VIR_PCI_STUB_DRIVER_VFIO); ++ virPCIDeviceSetStubDriverType(pci, VIR_PCI_STUB_DRIVER_VFIO); + virPCIDeviceSetManaged(pci, nvme->managed); + + return g_steal_pointer(&pci); +diff --git a/src/util/virpci.c b/src/util/virpci.c +index cc2b07bbba0..d86a81c2b1d 100644 +--- a/src/util/virpci.c ++++ b/src/util/virpci.c +@@ -87,7 +87,7 @@ struct _virPCIDevice { + + bool managed; + +- virPCIStubDriver stubDriver; ++ virPCIStubDriver stubDriverType; + + /* used by reattach function */ + bool unbind_from_stub; +@@ -1233,12 +1233,12 @@ virPCIDeviceBindToStub(virPCIDevice *dev) + g_autofree char *driverLink = NULL; + + /* Check the device is configured to use one of the known stub drivers */ +- if (dev->stubDriver == VIR_PCI_STUB_DRIVER_NONE) { ++ if (dev->stubDriverType == VIR_PCI_STUB_DRIVER_NONE) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("No stub driver configured for PCI device %1$s"), + dev->name); + return -1; +- } else if (!(stubDriverName = virPCIStubDriverTypeToString(dev->stubDriver))) { ++ } else if (!(stubDriverName = virPCIStubDriverTypeToString(dev->stubDriverType))) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Unknown stub driver configured for PCI device %1$s"), + dev->name); +@@ -1267,9 +1267,10 @@ virPCIDeviceBindToStub(virPCIDevice *dev) + /* virPCIDeviceDetach: + * + * Detach this device from the host driver, attach it to the stub +- * driver (previously set with virPCIDeviceSetStubDriver(), and add *a +- * copy* of the object to the inactiveDevs list (if provided). This +- * function will *never* consume dev, so the caller should free it. ++ * driver (previously set with virPCIDeviceSetStubDriverType(), and ++ * add *a copy* of the object to the inactiveDevs list (if provided). ++ * This function will *never* consume dev, so the caller should free ++ * it. + * + * Returns 0 on success, -1 on failure (will fail if the device is + * already in the activeDevs list, but will be a NOP if the device is +@@ -1287,7 +1288,7 @@ virPCIDeviceDetach(virPCIDevice *dev, + virPCIDeviceList *activeDevs, + virPCIDeviceList *inactiveDevs) + { +- if (virPCIProbeStubDriver(dev->stubDriver) < 0) ++ if (virPCIProbeStubDriver(dev->stubDriverType) < 0) + return -1; + + if (activeDevs && virPCIDeviceListFind(activeDevs, &dev->address)) { +@@ -1569,15 +1570,15 @@ virPCIDeviceGetManaged(virPCIDevice *dev) + } + + void +-virPCIDeviceSetStubDriver(virPCIDevice *dev, virPCIStubDriver driver) ++virPCIDeviceSetStubDriverType(virPCIDevice *dev, virPCIStubDriver driverType) + { +- dev->stubDriver = driver; ++ dev->stubDriverType = driverType; + } + + virPCIStubDriver +-virPCIDeviceGetStubDriver(virPCIDevice *dev) ++virPCIDeviceGetStubDriverType(virPCIDevice *dev) + { +- return dev->stubDriver; ++ return dev->stubDriverType; + } + + bool +diff --git a/src/util/virpci.h b/src/util/virpci.h +index 4d9193f24e5..485f535bc91 100644 +--- a/src/util/virpci.h ++++ b/src/util/virpci.h +@@ -134,9 +134,9 @@ int virPCIDeviceReset(virPCIDevice *dev, + void virPCIDeviceSetManaged(virPCIDevice *dev, + bool managed); + bool virPCIDeviceGetManaged(virPCIDevice *dev); +-void virPCIDeviceSetStubDriver(virPCIDevice *dev, +- virPCIStubDriver driver); +-virPCIStubDriver virPCIDeviceGetStubDriver(virPCIDevice *dev); ++void virPCIDeviceSetStubDriverType(virPCIDevice *dev, ++ virPCIStubDriver driverType); ++virPCIStubDriver virPCIDeviceGetStubDriverType(virPCIDevice *dev); + virPCIDeviceAddress *virPCIDeviceGetAddress(virPCIDevice *dev); + int virPCIDeviceSetUsedBy(virPCIDevice *dev, + const char *drv_name, +diff --git a/tests/virhostdevtest.c b/tests/virhostdevtest.c +index ee0d1c1e6b8..04e6c009081 100644 +--- a/tests/virhostdevtest.c ++++ b/tests/virhostdevtest.c +@@ -142,7 +142,7 @@ myInit(void) + if (!(dev[i] = virPCIDeviceNew(&subsys->u.pci.addr))) + goto cleanup; + +- virPCIDeviceSetStubDriver(dev[i], VIR_PCI_STUB_DRIVER_VFIO); ++ virPCIDeviceSetStubDriverType(dev[i], VIR_PCI_STUB_DRIVER_VFIO); + } + + for (i = 0; i < ndisks; i++) { +diff --git a/tests/virpcitest.c b/tests/virpcitest.c +index 769175d7c46..92cc8c07c6f 100644 +--- a/tests/virpcitest.c ++++ b/tests/virpcitest.c +@@ -107,7 +107,7 @@ testVirPCIDeviceDetach(const void *opaque G_GNUC_UNUSED) + if (!(dev[i] = virPCIDeviceNew(&devAddr))) + goto cleanup; + +- virPCIDeviceSetStubDriver(dev[i], VIR_PCI_STUB_DRIVER_VFIO); ++ virPCIDeviceSetStubDriverType(dev[i], VIR_PCI_STUB_DRIVER_VFIO); + + if (virPCIDeviceDetach(dev[i], activeDevs, inactiveDevs) < 0) + goto cleanup; +@@ -149,7 +149,7 @@ testVirPCIDeviceReset(const void *opaque G_GNUC_UNUSED) + if (!(dev[i] = virPCIDeviceNew(&devAddr))) + goto cleanup; + +- virPCIDeviceSetStubDriver(dev[i], VIR_PCI_STUB_DRIVER_VFIO); ++ virPCIDeviceSetStubDriverType(dev[i], VIR_PCI_STUB_DRIVER_VFIO); + + if (virPCIDeviceReset(dev[i], activeDevs, inactiveDevs) < 0) + goto cleanup; +@@ -190,7 +190,7 @@ testVirPCIDeviceReattach(const void *opaque G_GNUC_UNUSED) + CHECK_LIST_COUNT(activeDevs, 0); + CHECK_LIST_COUNT(inactiveDevs, i + 1); + +- virPCIDeviceSetStubDriver(dev[i], VIR_PCI_STUB_DRIVER_VFIO); ++ virPCIDeviceSetStubDriverType(dev[i], VIR_PCI_STUB_DRIVER_VFIO); + } + + CHECK_LIST_COUNT(activeDevs, 0); +@@ -249,7 +249,7 @@ testVirPCIDeviceDetachSingle(const void *opaque) + if (!dev) + goto cleanup; + +- virPCIDeviceSetStubDriver(dev, VIR_PCI_STUB_DRIVER_VFIO); ++ virPCIDeviceSetStubDriverType(dev, VIR_PCI_STUB_DRIVER_VFIO); + + if (virPCIDeviceDetach(dev, NULL, NULL) < 0) + goto cleanup; diff --git a/SPECS/libvirt.spec b/SPECS/libvirt.spec index a37d4e6..3b05ca2 100644 --- a/SPECS/libvirt.spec +++ b/SPECS/libvirt.spec @@ -229,7 +229,7 @@ Summary: Library providing a simple virtualization API Name: libvirt Version: 9.5.0 -Release: 6%{?dist}%{?extra_release} +Release: 7%{?dist}%{?extra_release}.alma.1 License: GPL-2.0-or-later AND LGPL-2.1-only AND LGPL-2.1-or-later AND OFL-1.1 URL: https://libvirt.org/ @@ -273,6 +273,25 @@ Patch32: libvirt-conf-Don-t-default-to-raw-format-for-loader-NVRAM.patch Patch33: libvirt-tests-Rename-firmware-auto-efi-format-loader-qcow2-nvram-path.patch Patch34: libvirt-tests-Reintroduce-firmware-auto-efi-format-mismatch.patch +# Patches were taken from: +# https://github.com/libvirt/libvirt/commit/cd2843f5463d93eee00fab31fe259ad1b5b27a27.patch +Patch35: libvirt-util-use-stubDriverType-instead-of-just-stubDriver.patch +# https://github.com/libvirt/libvirt/commit/1bb961797153a92a40a3c517114e4920c65672d4.patch +Patch36: libvirt-util-add-stub-driver-name-to-virPCIDevice-object.patch +# https://github.com/libvirt/libvirt/commit/222b66974e8256965c089fb0f244dc1e01f708e7.patch +Patch37: libvirt-util-rename-virPCIDeviceGetDriverPathAndName.patch +# https://github.com/libvirt/libvirt/commit/6ce071f6097d9e96892d5a6c7bd3040f43cc925b.patch +Patch38: libvirt-util-permit-existing-binding-to-VFIO-variant-driver.patch +# https://github.com/libvirt/libvirt/commit/2d9c9445b9cc093c870f101eb884ddeac3ae40f7.patch +Patch39: libvirt-util-probe-stub-driver-from-within-function-that-binds-to-stub-driver.patch +# https://github.com/libvirt/libvirt/commit/928296b044647fd3cbe409db6903afc791863a90.patch +Patch40: libvirt-util-honor-stubDriverName-when-probing.patch +# https://github.com/libvirt/libvirt/commit/24beaffec33efa3fa077d7b8596d97aa9a038a01.patch +Patch41: libvirt-node_device-support-binding-other-drivers-with-virNodeDevice.patch +# https://github.com/libvirt/libvirt/commit/10e8a518a05922d5592d1405054aed3195aebf06.patch +Patch42: libvirt-qemu-turn-two-multiline-log-messages-into-single-line.patch +# https://github.com/libvirt/libvirt/commit/bbfcf18f504b0eb165c0bbfe2f34b4e20d11c355.patch +Patch43: libvirt-docs-update-description-of-virsh-nodedev-detach.patch Requires: libvirt-daemon = %{version}-%{release} Requires: libvirt-daemon-config-network = %{version}-%{release} @@ -2519,6 +2538,18 @@ exit 0 %endif %changelog +* Thu Sep 05 2023 Eduard Abdullin - 9.5.0-7.alma.1 +- docs: update description of virsh nodedev-detach --driver option +- qemu: turn two multiline log messages into single line +- util: add stub driver name to virPCIDevice object +- util: honor stubDriverName when probing/binding stub driver for a device +- util: permit existing binding to VFIO variant driver +- util: probe stub driver from within function that binds to stub driver +- util: rename virPCIDeviceGetDriverPathAndName +- util: use "stubDriverType" instead of just "stubDriver" +- node_device: support binding other drivers with virNodeDeviceDetachFlags() + + * Fri Aug 25 2023 Jiri Denemark - 9.5.0-6 - tests: Use DO_TEST_CAPS_*_ABI_UPDATE() for ppc64 (rhbz#2196178) - tests: Switch to firmware autoselection for hvf (rhbz#2196178)