[libvirt] [PATCH v3 08/13] Rename all PCI device functions to have a standard name prefix

From: "Daniel P. Berrange" <berrange(a)redhat.com&gt; Rename all the pciDeviceXXX and pciXXXDevice APIs to have a fixed virPCIDevice name prefix --- src/conf/node_device_conf.c | 1 - src/conf/node_device_conf.h | 5 +- src/libvirt_private.syms | 74 ++-- src/network/bridge_driver.c | 2 +- src/node_device/node_device_udev.c | 4 +- src/qemu/qemu_agent.c | 1 - src/qemu/qemu_conf.h | 5 +- src/qemu/qemu_driver.c | 52 +-- src/qemu/qemu_hostdev.c | 244 ++++++------- src/qemu/qemu_hostdev.h | 2 +- src/qemu/qemu_hotplug.c | 18 +- src/security/security_apparmor.c | 17 +- src/security/security_dac.c | 32 +- src/security/security_selinux.c | 30 +- src/security/virt-aa-helper.c | 10 +- src/util/virnetdev.c | 34 +- src/util/virnetdev.h | 2 +- src/util/virpci.c | 676 ++++++++++++++++++------------------- src/util/virpci.h | 174 +++++----- src/xen/xen_driver.c | 24 +- 20 files changed, 709 insertions(+), 698 deletions(-) diff --git a/src/conf/node_device_conf.c b/src/conf/node_device_conf.c index 53b6af2..af89fe3 100644 --- a/src/conf/node_device_conf.c +++ b/src/conf/node_device_conf.c @@ -36,7 +36,6 @@ #include "virutil.h" #include "virbuffer.h" #include "viruuid.h" -#include "virpci.h" #include "virrandom.h" #define VIR_FROM_THIS VIR_FROM_NODEDEV diff --git a/src/conf/node_device_conf.h b/src/conf/node_device_conf.h index 12c36d8..03380df 100644 --- a/src/conf/node_device_conf.h +++ b/src/conf/node_device_conf.h @@ -28,6 +28,7 @@ # include "internal.h" # include "virutil.h" # include "virthread.h" +# include "virpci.h" # include <libxml/tree.h> @@ -111,8 +112,8 @@ struct _virNodeDevCapsDef { unsigned int class; char *product_name; char *vendor_name; - struct pci_config_address *physical_function; - struct pci_config_address **virtual_functions; + virPCIDeviceAddressPtr physical_function; + virPCIDeviceAddressPtr *virtual_functions; unsigned int num_virtual_functions; unsigned int flags; } pci_dev; diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 87171ae..ae0e7a7 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -991,43 +991,43 @@ virNWFilterVarValueGetSimple; # pci.h -pciConfigAddressToSysfsFile; -pciDettachDevice; -pciDeviceFileIterate; -pciDeviceGetManaged; -pciDeviceGetName; -pciDeviceGetRemoveSlot; -pciDeviceGetReprobe; -pciDeviceGetUnbindFromStub; -pciDeviceGetUsedBy; -pciDeviceGetVirtualFunctionInfo; -pciDeviceIsAssignable; -pciDeviceIsVirtualFunction; -pciDeviceListAdd; -pciDeviceListCount; -pciDeviceListDel; -pciDeviceListFind; -pciDeviceListFindIndex; -pciDeviceListFree; -pciDeviceListGet; -pciDeviceListNew; -pciDeviceListSteal; -pciDeviceListStealIndex; -pciDeviceNetName; -pciDeviceReAttachInit; -pciDeviceSetManaged; -pciDeviceSetRemoveSlot; -pciDeviceSetReprobe; -pciDeviceSetUnbindFromStub; -pciDeviceSetUsedBy; -pciFreeDevice; -pciGetDevice; -pciGetPhysicalFunction; -pciGetVirtualFunctionIndex; -pciGetVirtualFunctions; -pciReAttachDevice; -pciResetDevice; -pciWaitForDeviceCleanup; +virPCIDeviceAddressGetSysfsFile; +virPCIDeviceDettach; +virPCIDeviceFileIterate; +virPCIDeviceFree; +virPCIDeviceGetManaged; +virPCIDeviceGetName; +virPCIDeviceGetRemoveSlot; +virPCIDeviceGetReprobe; +virPCIDeviceGetUnbindFromStub; +virPCIDeviceGetUsedBy; +virPCIDeviceIsAssignable; +virPCIDeviceListAdd; +virPCIDeviceListCount; +virPCIDeviceListDel; +virPCIDeviceListFind; +virPCIDeviceListFindIndex; +virPCIDeviceListFree; +virPCIDeviceListGet; +virPCIDeviceListNew; +virPCIDeviceListSteal; +virPCIDeviceListStealIndex; +virPCIDeviceNew; +virPCIDeviceReAttach; +virPCIDeviceReAttachInit; +virPCIDeviceReset; +virPCIDeviceSetManaged; +virPCIDeviceSetRemoveSlot; +virPCIDeviceSetReprobe; +virPCIDeviceSetUnbindFromStub; +virPCIDeviceSetUsedBy; +virPCIDeviceWaitForCleanup; +virPCIGetNetName; +virPCIGetPhysicalFunction; +virPCIGetVirtualFunctionIndex; +virPCIGetVirtualFunctionInfo; +virPCIGetVirtualFunctions; +virPCIIsVirtualFunction; # secret_conf.h diff --git a/src/network/bridge_driver.c b/src/network/bridge_driver.c index 21255f0..dadcc6c 100644 --- a/src/network/bridge_driver.c +++ b/src/network/bridge_driver.c @@ -3622,7 +3622,7 @@ static int networkCreateInterfacePool(virNetworkDefPtr netdef) { unsigned int num_virt_fns = 0; char **vfname = NULL; - struct pci_config_address **virt_fns; + virPCIDeviceAddressPtr *virt_fns; int ret = -1, ii = 0; if ((virNetDevGetVirtualFunctions(netdef->forward.pfs->dev, diff --git a/src/node_device/node_device_udev.c b/src/node_device/node_device_udev.c index a9b30b2..566e7ab 100644 --- a/src/node_device/node_device_udev.c +++ b/src/node_device/node_device_udev.c @@ -481,10 +481,10 @@ static int udevProcessPCI(struct udev_device *device, goto out; } - if (!pciGetPhysicalFunction(syspath, &data->pci_dev.physical_function)) + if (!virPCIGetPhysicalFunction(syspath, &data->pci_dev.physical_function)) data->pci_dev.flags |= VIR_NODE_DEV_CAP_FLAG_PCI_PHYSICAL_FUNCTION; - if (!pciGetVirtualFunctions(syspath, &data->pci_dev.virtual_functions, + if (!virPCIGetVirtualFunctions(syspath, &data->pci_dev.virtual_functions, &data->pci_dev.num_virtual_functions) || data->pci_dev.num_virtual_functions > 0) data->pci_dev.flags |= VIR_NODE_DEV_CAP_FLAG_PCI_VIRTUAL_FUNCTION; diff --git a/src/qemu/qemu_agent.c b/src/qemu/qemu_agent.c index ae54228..05641da 100644 --- a/src/qemu/qemu_agent.c +++ b/src/qemu/qemu_agent.c @@ -33,7 +33,6 @@ #include <sys/time.h> #include "qemu_agent.h" -#include "qemu_command.h" #include "viralloc.h" #include "virlog.h" #include "virerror.h" diff --git a/src/qemu/qemu_conf.h b/src/qemu/qemu_conf.h index 2b27a3e..be45cf0 100644 --- a/src/qemu/qemu_conf.h +++ b/src/qemu/qemu_conf.h @@ -181,11 +181,10 @@ struct _virQEMUDriver { virSecurityManagerPtr securityManager; - pciDeviceList *activePciHostdevs; + virPCIDeviceListPtr activePciHostdevs; + virPCIDeviceListPtr inactivePciHostdevs; usbDeviceList *activeUsbHostdevs; - pciDeviceList *inactivePciHostdevs; - virHashTablePtr sharedDisks; virPortAllocatorPtr remotePorts; diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 2d0cd77..ce6df5c 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -774,13 +774,13 @@ qemuStartup(bool privileged, if (qemuSecurityInit(qemu_driver) < 0) goto error; - if ((qemu_driver->activePciHostdevs = pciDeviceListNew()) == NULL) + if ((qemu_driver->activePciHostdevs = virPCIDeviceListNew()) == NULL) goto error; if ((qemu_driver->activeUsbHostdevs = usbDeviceListNew()) == NULL) goto error; - if ((qemu_driver->inactivePciHostdevs = pciDeviceListNew()) == NULL) + if ((qemu_driver->inactivePciHostdevs = virPCIDeviceListNew()) == NULL) goto error; if (!(qemu_driver->sharedDisks = virHashCreate(30, NULL))) @@ -1047,8 +1047,8 @@ qemuShutdown(void) { qemuDriverLock(qemu_driver); virNWFilterUnRegisterCallbackDriver(&qemuCallbackDriver); - pciDeviceListFree(qemu_driver->activePciHostdevs); - pciDeviceListFree(qemu_driver->inactivePciHostdevs); + virPCIDeviceListFree(qemu_driver->activePciHostdevs); + virPCIDeviceListFree(qemu_driver->inactivePciHostdevs); usbDeviceListFree(qemu_driver->activeUsbHostdevs); virHashFree(qemu_driver->sharedDisks); virCapabilitiesFree(qemu_driver->caps); @@ -10017,7 +10017,7 @@ static int qemuNodeDeviceDettach(virNodeDevicePtr dev) { virQEMUDriverPtr driver = dev->conn->privateData; - pciDevice *pci; + virPCIDevicePtr pci; unsigned domain, bus, slot, function; int ret = -1; bool in_inactive_list = false; @@ -10025,22 +10025,22 @@ qemuNodeDeviceDettach(virNodeDevicePtr dev) if (qemuNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0) return -1; - pci = pciGetDevice(domain, bus, slot, function); + pci = virPCIDeviceNew(domain, bus, slot, function); if (!pci) return -1; qemuDriverLock(driver); - in_inactive_list = pciDeviceListFind(driver->inactivePciHostdevs, pci); + in_inactive_list = virPCIDeviceListFind(driver->inactivePciHostdevs, pci); - if (pciDettachDevice(pci, driver->activePciHostdevs, - driver->inactivePciHostdevs, "pci-stub") < 0) + if (virPCIDeviceDettach(pci, driver->activePciHostdevs, + driver->inactivePciHostdevs, "pci-stub") < 0) goto out; ret = 0; out: qemuDriverUnlock(driver); if (in_inactive_list) - pciFreeDevice(pci); + virPCIDeviceFree(pci); return ret; } @@ -10048,43 +10048,43 @@ static int qemuNodeDeviceReAttach(virNodeDevicePtr dev) { virQEMUDriverPtr driver = dev->conn->privateData; - pciDevice *pci; - pciDevice *other; + virPCIDevicePtr pci; + virPCIDevicePtr other; unsigned domain, bus, slot, function; int ret = -1; if (qemuNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0) return -1; - pci = pciGetDevice(domain, bus, slot, function); + pci = virPCIDeviceNew(domain, bus, slot, function); if (!pci) return -1; - other = pciDeviceListFind(driver->activePciHostdevs, pci); + other = virPCIDeviceListFind(driver->activePciHostdevs, pci); if (other) { - const char *other_name = pciDeviceGetUsedBy(other); + const char *other_name = virPCIDeviceGetUsedBy(other); if (other_name) virReportError(VIR_ERR_OPERATION_INVALID, _("PCI device %s is still in use by domain %s"), - pciDeviceGetName(pci), other_name); + virPCIDeviceGetName(pci), other_name); else virReportError(VIR_ERR_OPERATION_INVALID, _("PCI device %s is still in use"), - pciDeviceGetName(pci)); + virPCIDeviceGetName(pci)); } - pciDeviceReAttachInit(pci); + virPCIDeviceReAttachInit(pci); qemuDriverLock(driver); - if (pciReAttachDevice(pci, driver->activePciHostdevs, - driver->inactivePciHostdevs, "pci-stub") < 0) + if (virPCIDeviceReAttach(pci, driver->activePciHostdevs, + driver->inactivePciHostdevs, "pci-stub") < 0) goto out; ret = 0; out: qemuDriverUnlock(driver); - pciFreeDevice(pci); + virPCIDeviceFree(pci); return ret; } @@ -10092,27 +10092,27 @@ static int qemuNodeDeviceReset(virNodeDevicePtr dev) { virQEMUDriverPtr driver = dev->conn->privateData; - pciDevice *pci; + virPCIDevicePtr pci; unsigned domain, bus, slot, function; int ret = -1; if (qemuNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0) return -1; - pci = pciGetDevice(domain, bus, slot, function); + pci = virPCIDeviceNew(domain, bus, slot, function); if (!pci) return -1; qemuDriverLock(driver); - if (pciResetDevice(pci, driver->activePciHostdevs, - driver->inactivePciHostdevs) < 0) + if (virPCIDeviceReset(pci, driver->activePciHostdevs, + driver->inactivePciHostdevs) < 0) goto out; ret = 0; out: qemuDriverUnlock(driver); - pciFreeDevice(pci); + virPCIDeviceFree(pci); return ret; } diff --git a/src/qemu/qemu_hostdev.c b/src/qemu/qemu_hostdev.c index 1b8a9cd..b5d7c5e 100644 --- a/src/qemu/qemu_hostdev.c +++ b/src/qemu/qemu_hostdev.c @@ -33,84 +33,84 @@ #define VIR_FROM_THIS VIR_FROM_QEMU -static pciDeviceList * +static virPCIDeviceListPtr qemuGetPciHostDeviceList(virDomainHostdevDefPtr *hostdevs, int nhostdevs) { - pciDeviceList *list; + virPCIDeviceListPtr list; int i; - if (!(list = pciDeviceListNew())) + if (!(list = virPCIDeviceListNew())) return NULL; for (i = 0 ; i < nhostdevs ; i++) { virDomainHostdevDefPtr hostdev = hostdevs[i]; - pciDevice *dev; + virPCIDevicePtr dev; if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) continue; if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) continue; - dev = pciGetDevice(hostdev->source.subsys.u.pci.domain, - hostdev->source.subsys.u.pci.bus, - hostdev->source.subsys.u.pci.slot, - hostdev->source.subsys.u.pci.function); + dev = virPCIDeviceNew(hostdev->source.subsys.u.pci.domain, + hostdev->source.subsys.u.pci.bus, + hostdev->source.subsys.u.pci.slot, + hostdev->source.subsys.u.pci.function); if (!dev) { - pciDeviceListFree(list); + virPCIDeviceListFree(list); return NULL; } - if (pciDeviceListAdd(list, dev) < 0) { - pciFreeDevice(dev); - pciDeviceListFree(list); + if (virPCIDeviceListAdd(list, dev) < 0) { + virPCIDeviceFree(dev); + virPCIDeviceListFree(list); return NULL; } - pciDeviceSetManaged(dev, hostdev->managed); + virPCIDeviceSetManaged(dev, hostdev->managed); } return list; } -static pciDeviceList * +static virPCIDeviceListPtr qemuGetActivePciHostDeviceList(virQEMUDriverPtr driver, virDomainHostdevDefPtr *hostdevs, int nhostdevs) { - pciDeviceList *list; + virPCIDeviceListPtr list; int i; - if (!(list = pciDeviceListNew())) + if (!(list = virPCIDeviceListNew())) return NULL; for (i = 0 ; i < nhostdevs ; i++) { virDomainHostdevDefPtr hostdev = hostdevs[i]; - pciDevice *dev; - pciDevice *activeDev; + virPCIDevicePtr dev; + virPCIDevicePtr activeDev; if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) continue; if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) continue; - dev = pciGetDevice(hostdev->source.subsys.u.pci.domain, - hostdev->source.subsys.u.pci.bus, - hostdev->source.subsys.u.pci.slot, - hostdev->source.subsys.u.pci.function); + dev = virPCIDeviceNew(hostdev->source.subsys.u.pci.domain, + hostdev->source.subsys.u.pci.bus, + hostdev->source.subsys.u.pci.slot, + hostdev->source.subsys.u.pci.function); if (!dev) { - pciDeviceListFree(list); + virPCIDeviceListFree(list); return NULL; } - if ((activeDev = pciDeviceListFind(driver->activePciHostdevs, dev))) { - if (pciDeviceListAdd(list, activeDev) < 0) { - pciFreeDevice(dev); - pciDeviceListFree(list); + if ((activeDev = virPCIDeviceListFind(driver->activePciHostdevs, dev))) { + if (virPCIDeviceListAdd(list, activeDev) < 0) { + virPCIDeviceFree(dev); + virPCIDeviceListFree(list); return NULL; } } - pciFreeDevice(dev); + virPCIDeviceFree(dev); } return list; @@ -126,7 +126,7 @@ int qemuUpdateActivePciHostdevs(virQEMUDriverPtr driver, return 0; for (i = 0; i < def->nhostdevs; i++) { - pciDevice *dev = NULL; + virPCIDevicePtr dev = NULL; hostdev = def->hostdevs[i]; if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) @@ -134,24 +134,24 @@ int qemuUpdateActivePciHostdevs(virQEMUDriverPtr driver, if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) continue; - dev = pciGetDevice(hostdev->source.subsys.u.pci.domain, - hostdev->source.subsys.u.pci.bus, - hostdev->source.subsys.u.pci.slot, - hostdev->source.subsys.u.pci.function); + dev = virPCIDeviceNew(hostdev->source.subsys.u.pci.domain, + hostdev->source.subsys.u.pci.bus, + hostdev->source.subsys.u.pci.slot, + hostdev->source.subsys.u.pci.function); if (!dev) return -1; - pciDeviceSetManaged(dev, hostdev->managed); - pciDeviceSetUsedBy(dev, def->name); + virPCIDeviceSetManaged(dev, hostdev->managed); + virPCIDeviceSetUsedBy(dev, def->name); /* Setup the original states for the PCI device */ - pciDeviceSetUnbindFromStub(dev, hostdev->origstates.states.pci.unbind_from_stub); - pciDeviceSetRemoveSlot(dev, hostdev->origstates.states.pci.remove_slot); - pciDeviceSetReprobe(dev, hostdev->origstates.states.pci.reprobe); + virPCIDeviceSetUnbindFromStub(dev, hostdev->origstates.states.pci.unbind_from_stub); + virPCIDeviceSetRemoveSlot(dev, hostdev->origstates.states.pci.remove_slot); + virPCIDeviceSetReprobe(dev, hostdev->origstates.states.pci.reprobe); - if (pciDeviceListAdd(driver->activePciHostdevs, dev) < 0) { - pciFreeDevice(dev); + if (virPCIDeviceListAdd(driver->activePciHostdevs, dev) < 0) { + virPCIDeviceFree(dev); return -1; } } @@ -203,14 +203,14 @@ qemuUpdateActiveUsbHostdevs(virQEMUDriverPtr driver, static int qemuDomainHostdevPciSysfsPath(virDomainHostdevDefPtr hostdev, char **sysfs_path) { - struct pci_config_address config_address; + virPCIDeviceAddress config_address; config_address.domain = hostdev->source.subsys.u.pci.domain; config_address.bus = hostdev->source.subsys.u.pci.bus; config_address.slot = hostdev->source.subsys.u.pci.slot; config_address.function = hostdev->source.subsys.u.pci.function; - return pciConfigAddressToSysfsFile(&config_address, sysfs_path); + return virPCIDeviceAddressGetSysfsFile(&config_address, sysfs_path); } int @@ -222,7 +222,7 @@ qemuDomainHostdevIsVirtualFunction(virDomainHostdevDefPtr hostdev) if (qemuDomainHostdevPciSysfsPath(hostdev, &sysfs_path) < 0) return ret; - ret = pciDeviceIsVirtualFunction(sysfs_path); + ret = virPCIIsVirtualFunction(sysfs_path); VIR_FREE(sysfs_path); @@ -239,12 +239,12 @@ qemuDomainHostdevNetDevice(virDomainHostdevDefPtr hostdev, char **linkdev, if (qemuDomainHostdevPciSysfsPath(hostdev, &sysfs_path) < 0) return ret; - if (pciDeviceIsVirtualFunction(sysfs_path) == 1) { - if (pciDeviceGetVirtualFunctionInfo(sysfs_path, linkdev, - vf) < 0) + if (virPCIIsVirtualFunction(sysfs_path) == 1) { + if (virPCIGetVirtualFunctionInfo(sysfs_path, linkdev, + vf) < 0) goto cleanup; } else { - if (pciDeviceNetName(sysfs_path, linkdev) < 0) + if (virPCIGetNetName(sysfs_path, linkdev) < 0) goto cleanup; *vf = -1; } @@ -406,7 +406,7 @@ int qemuPrepareHostdevPCIDevices(virQEMUDriverPtr driver, virDomainHostdevDefPtr *hostdevs, int nhostdevs) { - pciDeviceList *pcidevs; + virPCIDeviceListPtr pcidevs; int last_processed_hostdev_vf = -1; int i; int ret = -1; @@ -427,48 +427,48 @@ int qemuPrepareHostdevPCIDevices(virQEMUDriverPtr driver, * to pci-stub.ko */ - for (i = 0; i < pciDeviceListCount(pcidevs); i++) { - pciDevice *dev = pciDeviceListGet(pcidevs, i); - pciDevice *other; + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); + virPCIDevicePtr other; - if (!pciDeviceIsAssignable(dev, !cfg->relaxedACS)) { + if (!virPCIDeviceIsAssignable(dev, !cfg->relaxedACS)) { virReportError(VIR_ERR_OPERATION_INVALID, _("PCI device %s is not assignable"), - pciDeviceGetName(dev)); + virPCIDeviceGetName(dev)); goto cleanup; } /* The device is in use by other active domain if * the dev is in list driver->activePciHostdevs. */ - if ((other = pciDeviceListFind(driver->activePciHostdevs, dev))) { - const char *other_name = pciDeviceGetUsedBy(other); + if ((other = virPCIDeviceListFind(driver->activePciHostdevs, dev))) { + const char *other_name = virPCIDeviceGetUsedBy(other); if (other_name) virReportError(VIR_ERR_OPERATION_INVALID, _("PCI device %s is in use by domain %s"), - pciDeviceGetName(dev), other_name); + virPCIDeviceGetName(dev), other_name); else virReportError(VIR_ERR_OPERATION_INVALID, _("PCI device %s is already in use"), - pciDeviceGetName(dev)); + virPCIDeviceGetName(dev)); goto cleanup; } } /* Loop 2: detach managed devices */ - for (i = 0; i < pciDeviceListCount(pcidevs); i++) { - pciDevice *dev = pciDeviceListGet(pcidevs, i); - if (pciDeviceGetManaged(dev) && - pciDettachDevice(dev, driver->activePciHostdevs, NULL, "pci-stub") < 0) + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); + if (virPCIDeviceGetManaged(dev) && + virPCIDeviceDettach(dev, driver->activePciHostdevs, NULL, "pci-stub") < 0) goto reattachdevs; } /* Loop 3: Now that all the PCI hostdevs have been detached, we * can safely reset them */ - for (i = 0; i < pciDeviceListCount(pcidevs); i++) { - pciDevice *dev = pciDeviceListGet(pcidevs, i); - if (pciResetDevice(dev, driver->activePciHostdevs, - driver->inactivePciHostdevs) < 0) + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); + if (virPCIDeviceReset(dev, driver->activePciHostdevs, + driver->inactivePciHostdevs) < 0) goto reattachdevs; } @@ -491,35 +491,35 @@ int qemuPrepareHostdevPCIDevices(virQEMUDriverPtr driver, } /* Loop 5: Now mark all the devices as active */ - for (i = 0; i < pciDeviceListCount(pcidevs); i++) { - pciDevice *dev = pciDeviceListGet(pcidevs, i); - if (pciDeviceListAdd(driver->activePciHostdevs, dev) < 0) + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); + if (virPCIDeviceListAdd(driver->activePciHostdevs, dev) < 0) goto inactivedevs; } /* Loop 6: Now remove the devices from inactive list. */ - for (i = 0; i < pciDeviceListCount(pcidevs); i++) { - pciDevice *dev = pciDeviceListGet(pcidevs, i); - pciDeviceListDel(driver->inactivePciHostdevs, dev); + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); + virPCIDeviceListDel(driver->inactivePciHostdevs, dev); } /* Loop 7: Now set the used_by_domain of the device in * driver->activePciHostdevs as domain name. */ - for (i = 0; i < pciDeviceListCount(pcidevs); i++) { - pciDevice *dev, *activeDev; + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevicePtr dev, activeDev; - dev = pciDeviceListGet(pcidevs, i); - activeDev = pciDeviceListFind(driver->activePciHostdevs, dev); + dev = virPCIDeviceListGet(pcidevs, i); + activeDev = virPCIDeviceListFind(driver->activePciHostdevs, dev); if (activeDev) - pciDeviceSetUsedBy(activeDev, name); + virPCIDeviceSetUsedBy(activeDev, name); } /* Loop 8: Now set the original states for hostdev def */ for (i = 0; i < nhostdevs; i++) { - pciDevice *dev; - pciDevice *pcidev; + virPCIDevicePtr dev; + virPCIDevicePtr pcidev; virDomainHostdevDefPtr hostdev = hostdevs[i]; if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) @@ -527,41 +527,41 @@ int qemuPrepareHostdevPCIDevices(virQEMUDriverPtr driver, if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) continue; - dev = pciGetDevice(hostdev->source.subsys.u.pci.domain, - hostdev->source.subsys.u.pci.bus, - hostdev->source.subsys.u.pci.slot, - hostdev->source.subsys.u.pci.function); + dev = virPCIDeviceNew(hostdev->source.subsys.u.pci.domain, + hostdev->source.subsys.u.pci.bus, + hostdev->source.subsys.u.pci.slot, + hostdev->source.subsys.u.pci.function); /* original states "unbind_from_stub", "remove_slot", * "reprobe" were already set by pciDettachDevice in * loop 2. */ - if ((pcidev = pciDeviceListFind(pcidevs, dev))) { + if ((pcidev = virPCIDeviceListFind(pcidevs, dev))) { hostdev->origstates.states.pci.unbind_from_stub = - pciDeviceGetUnbindFromStub(pcidev); + virPCIDeviceGetUnbindFromStub(pcidev); hostdev->origstates.states.pci.remove_slot = - pciDeviceGetRemoveSlot(pcidev); + virPCIDeviceGetRemoveSlot(pcidev); hostdev->origstates.states.pci.reprobe = - pciDeviceGetReprobe(pcidev); + virPCIDeviceGetReprobe(pcidev); } - pciFreeDevice(dev); + virPCIDeviceFree(dev); } /* Loop 9: Now steal all the devices from pcidevs */ - while (pciDeviceListCount(pcidevs) > 0) - pciDeviceListStealIndex(pcidevs, 0); + while (virPCIDeviceListCount(pcidevs) > 0) + virPCIDeviceListStealIndex(pcidevs, 0); ret = 0; goto cleanup; inactivedevs: /* Only steal all the devices from driver->activePciHostdevs. We will - * free them in pciDeviceListFree(). + * free them in virPCIDeviceListFree(). */ - while (pciDeviceListCount(pcidevs) > 0) { - pciDevice *dev = pciDeviceListGet(pcidevs, 0); - pciDeviceListSteal(driver->activePciHostdevs, dev); + while (virPCIDeviceListCount(pcidevs) > 0) { + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, 0); + virPCIDeviceListSteal(driver->activePciHostdevs, dev); } resetvfnetconfig: @@ -574,13 +574,13 @@ resetvfnetconfig: } reattachdevs: - for (i = 0; i < pciDeviceListCount(pcidevs); i++) { - pciDevice *dev = pciDeviceListGet(pcidevs, i); - pciReAttachDevice(dev, driver->activePciHostdevs, NULL, "pci-stub"); + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); + virPCIDeviceReAttach(dev, driver->activePciHostdevs, NULL, "pci-stub"); } cleanup: - pciDeviceListFree(pcidevs); + virPCIDeviceListFree(pcidevs); virObjectUnref(cfg); return ret; } @@ -813,33 +813,33 @@ int qemuPrepareHostDevices(virQEMUDriverPtr driver, } -void qemuReattachPciDevice(pciDevice *dev, virQEMUDriverPtr driver) +void qemuReattachPciDevice(virPCIDevicePtr dev, virQEMUDriverPtr driver) { int retries = 100; /* If the device is not managed and was attached to guest * successfully, it must have been inactive. */ - if (!pciDeviceGetManaged(dev)) { - if (pciDeviceListAdd(driver->inactivePciHostdevs, dev) < 0) - pciFreeDevice(dev); + if (!virPCIDeviceGetManaged(dev)) { + if (virPCIDeviceListAdd(driver->inactivePciHostdevs, dev) < 0) + virPCIDeviceFree(dev); return; } - while (pciWaitForDeviceCleanup(dev, "kvm_assigned_device") + while (virPCIDeviceWaitForCleanup(dev, "kvm_assigned_device") && retries) { usleep(100*1000); retries--; } - if (pciReAttachDevice(dev, driver->activePciHostdevs, - driver->inactivePciHostdevs, "pci-stub") < 0) { + if (virPCIDeviceReAttach(dev, driver->activePciHostdevs, + driver->inactivePciHostdevs, "pci-stub") < 0) { virErrorPtr err = virGetLastError(); VIR_ERROR(_("Failed to re-attach PCI device: %s"), err ? err->message : _("unknown error")); virResetError(err); } - pciFreeDevice(dev); + virPCIDeviceFree(dev); } @@ -848,7 +848,7 @@ void qemuDomainReAttachHostdevDevices(virQEMUDriverPtr driver, virDomainHostdevDefPtr *hostdevs, int nhostdevs) { - pciDeviceList *pcidevs; + virPCIDeviceListPtr pcidevs; int i; virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); @@ -856,7 +856,7 @@ void qemuDomainReAttachHostdevDevices(virQEMUDriverPtr driver, hostdevs, nhostdevs))) { virErrorPtr err = virGetLastError(); - VIR_ERROR(_("Failed to allocate pciDeviceList: %s"), + VIR_ERROR(_("Failed to allocate virPCIDeviceList: %s"), err ? err->message : _("unknown error")); virResetError(err); goto cleanup; @@ -866,22 +866,22 @@ void qemuDomainReAttachHostdevDevices(virQEMUDriverPtr driver, * them and reset all the devices before re-attach. * Attach mac and port profile parameters to devices */ - for (i = 0; i < pciDeviceListCount(pcidevs); i++) { - pciDevice *dev = pciDeviceListGet(pcidevs, i); - pciDevice *activeDev = NULL; + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); + virPCIDevicePtr activeDev = NULL; /* Never delete the dev from list driver->activePciHostdevs * if it's used by other domain. */ - activeDev = pciDeviceListFind(driver->activePciHostdevs, dev); + activeDev = virPCIDeviceListFind(driver->activePciHostdevs, dev); if (activeDev && - STRNEQ_NULLABLE(name, pciDeviceGetUsedBy(activeDev))) { - pciDeviceListSteal(pcidevs, dev); + STRNEQ_NULLABLE(name, virPCIDeviceGetUsedBy(activeDev))) { + virPCIDeviceListSteal(pcidevs, dev); continue; } - /* pciDeviceListFree() will take care of freeing the dev. */ - pciDeviceListSteal(driver->activePciHostdevs, dev); + /* virPCIDeviceListFree() will take care of freeing the dev. */ + virPCIDeviceListSteal(driver->activePciHostdevs, dev); } /* @@ -900,10 +900,10 @@ void qemuDomainReAttachHostdevDevices(virQEMUDriverPtr driver, } } - for (i = 0; i < pciDeviceListCount(pcidevs); i++) { - pciDevice *dev = pciDeviceListGet(pcidevs, i); - if (pciResetDevice(dev, driver->activePciHostdevs, - driver->inactivePciHostdevs) < 0) { + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); + if (virPCIDeviceReset(dev, driver->activePciHostdevs, + driver->inactivePciHostdevs) < 0) { virErrorPtr err = virGetLastError(); VIR_ERROR(_("Failed to reset PCI device: %s"), err ? err->message : _("unknown error")); @@ -911,12 +911,12 @@ void qemuDomainReAttachHostdevDevices(virQEMUDriverPtr driver, } } - while (pciDeviceListCount(pcidevs) > 0) { - pciDevice *dev = pciDeviceListStealIndex(pcidevs, 0); + while (virPCIDeviceListCount(pcidevs) > 0) { + virPCIDevicePtr dev = virPCIDeviceListStealIndex(pcidevs, 0); qemuReattachPciDevice(dev, driver); } - pciDeviceListFree(pcidevs); + virPCIDeviceListFree(pcidevs); cleanup: virObjectUnref(cfg); } diff --git a/src/qemu/qemu_hostdev.h b/src/qemu/qemu_hostdev.h index 9ef2385..8bfd36f 100644 --- a/src/qemu/qemu_hostdev.h +++ b/src/qemu/qemu_hostdev.h @@ -45,7 +45,7 @@ int qemuPrepareHostdevUSBDevices(virQEMUDriverPtr driver, int qemuPrepareHostDevices(virQEMUDriverPtr driver, virDomainDefPtr def, bool coldBoot); -void qemuReattachPciDevice(pciDevice *dev, virQEMUDriverPtr driver); +void qemuReattachPciDevice(virPCIDevicePtr dev, virQEMUDriverPtr driver); void qemuDomainReAttachHostdevDevices(virQEMUDriverPtr driver, const char *name, virDomainHostdevDefPtr *hostdevs, diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c index 6c328d6..d942de5 100644 --- a/src/qemu/qemu_hotplug.c +++ b/src/qemu/qemu_hotplug.c @@ -2331,8 +2331,8 @@ qemuDomainDetachHostPciDevice(virQEMUDriverPtr driver, qemuDomainObjPrivatePtr priv = vm->privateData; virDomainHostdevSubsysPtr subsys = &detach->source.subsys; int ret = -1, rv; - pciDevice *pci; - pciDevice *activePci; + virPCIDevicePtr pci; + virPCIDevicePtr activePci; virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); if (qemuIsMultiFunctionDevice(vm->def, detach->info)) { @@ -2368,20 +2368,20 @@ qemuDomainDetachHostPciDevice(virQEMUDriverPtr driver, if (detach->parent.data.net) qemuDomainHostdevNetConfigRestore(detach, cfg->stateDir); - pci = pciGetDevice(subsys->u.pci.domain, subsys->u.pci.bus, - subsys->u.pci.slot, subsys->u.pci.function); + pci = virPCIDeviceNew(subsys->u.pci.domain, subsys->u.pci.bus, + subsys->u.pci.slot, subsys->u.pci.function); if (pci) { - activePci = pciDeviceListSteal(driver->activePciHostdevs, pci); + activePci = virPCIDeviceListSteal(driver->activePciHostdevs, pci); if (activePci && - pciResetDevice(activePci, driver->activePciHostdevs, - driver->inactivePciHostdevs) == 0) { + virPCIDeviceReset(activePci, driver->activePciHostdevs, + driver->inactivePciHostdevs) == 0) { qemuReattachPciDevice(activePci, driver); ret = 0; } else { /* reset of the device failed, treat it as if it was returned */ - pciFreeDevice(activePci); + virPCIDeviceFree(activePci); } - pciFreeDevice(pci); + virPCIDeviceFree(pci); } if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) && diff --git a/src/security/security_apparmor.c b/src/security/security_apparmor.c index c23ba87..3c87a0f 100644 --- a/src/security/security_apparmor.c +++ b/src/security/security_apparmor.c @@ -328,8 +328,8 @@ AppArmorSetSecurityUSBLabel(usbDevice *dev ATTRIBUTE_UNUSED, } static int -AppArmorSetSecurityPCILabel(pciDevice *dev ATTRIBUTE_UNUSED, - const char *file, void *opaque) +AppArmorSetSecurityPCILabel(virPCIDevicePtr dev ATTRIBUTE_UNUSED, + const char *file, void *opaque) { struct SDPDOP *ptr = opaque; virDomainDefPtr def = ptr->def; @@ -783,16 +783,17 @@ AppArmorSetSecurityHostdevLabel(virSecurityManagerPtr mgr, } case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: { - pciDevice *pci = pciGetDevice(dev->source.subsys.u.pci.domain, - dev->source.subsys.u.pci.bus, - dev->source.subsys.u.pci.slot, - dev->source.subsys.u.pci.function); + virPCIDevicePtr pci = + virPCIDeviceNew(dev->source.subsys.u.pci.domain, + dev->source.subsys.u.pci.bus, + dev->source.subsys.u.pci.slot, + dev->source.subsys.u.pci.function); if (!pci) goto done; - ret = pciDeviceFileIterate(pci, AppArmorSetSecurityPCILabel, ptr); - pciFreeDevice(pci); + ret = virPCIDeviceFileIterate(pci, AppArmorSetSecurityPCILabel, ptr); + virPCIDeviceFree(pci); break; } diff --git a/src/security/security_dac.c b/src/security/security_dac.c index 93a0301..b52bfa1 100644 --- a/src/security/security_dac.c +++ b/src/security/security_dac.c @@ -434,7 +434,7 @@ virSecurityDACRestoreSecurityImageLabel(virSecurityManagerPtr mgr, static int -virSecurityDACSetSecurityPCILabel(pciDevice *dev ATTRIBUTE_UNUSED, +virSecurityDACSetSecurityPCILabel(virPCIDevicePtr dev ATTRIBUTE_UNUSED, const char *file, void *opaque) { @@ -507,17 +507,18 @@ virSecurityDACSetSecurityHostdevLabel(virSecurityManagerPtr mgr, } case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: { - pciDevice *pci = pciGetDevice(dev->source.subsys.u.pci.domain, - dev->source.subsys.u.pci.bus, - dev->source.subsys.u.pci.slot, - dev->source.subsys.u.pci.function); + virPCIDevicePtr pci = + virPCIDeviceNew(dev->source.subsys.u.pci.domain, + dev->source.subsys.u.pci.bus, + dev->source.subsys.u.pci.slot, + dev->source.subsys.u.pci.function); if (!pci) goto done; - ret = pciDeviceFileIterate(pci, virSecurityDACSetSecurityPCILabel, - params); - pciFreeDevice(pci); + ret = virPCIDeviceFileIterate(pci, virSecurityDACSetSecurityPCILabel, + params); + virPCIDeviceFree(pci); break; } @@ -533,7 +534,7 @@ done: static int -virSecurityDACRestoreSecurityPCILabel(pciDevice *dev ATTRIBUTE_UNUSED, +virSecurityDACRestoreSecurityPCILabel(virPCIDevicePtr dev ATTRIBUTE_UNUSED, const char *file, void *opaque ATTRIBUTE_UNUSED) { @@ -586,16 +587,17 @@ virSecurityDACRestoreSecurityHostdevLabel(virSecurityManagerPtr mgr, } case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: { - pciDevice *pci = pciGetDevice(dev->source.subsys.u.pci.domain, - dev->source.subsys.u.pci.bus, - dev->source.subsys.u.pci.slot, - dev->source.subsys.u.pci.function); + virPCIDevicePtr pci = + virPCIDeviceNew(dev->source.subsys.u.pci.domain, + dev->source.subsys.u.pci.bus, + dev->source.subsys.u.pci.slot, + dev->source.subsys.u.pci.function); if (!pci) goto done; - ret = pciDeviceFileIterate(pci, virSecurityDACRestoreSecurityPCILabel, mgr); - pciFreeDevice(pci); + ret = virPCIDeviceFileIterate(pci, virSecurityDACRestoreSecurityPCILabel, mgr); + virPCIDeviceFree(pci); break; } diff --git a/src/security/security_selinux.c b/src/security/security_selinux.c index fa2ee57..0676543 100644 --- a/src/security/security_selinux.c +++ b/src/security/security_selinux.c @@ -1159,7 +1159,7 @@ virSecuritySELinuxSetSecurityImageLabel(virSecurityManagerPtr mgr, static int -virSecuritySELinuxSetSecurityPCILabel(pciDevice *dev ATTRIBUTE_UNUSED, +virSecuritySELinuxSetSecurityPCILabel(virPCIDevicePtr dev ATTRIBUTE_UNUSED, const char *file, void *opaque) { virSecurityLabelDefPtr secdef; @@ -1213,16 +1213,17 @@ virSecuritySELinuxSetSecurityHostdevSubsysLabel(virDomainDefPtr def, } case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: { - pciDevice *pci = pciGetDevice(dev->source.subsys.u.pci.domain, - dev->source.subsys.u.pci.bus, - dev->source.subsys.u.pci.slot, - dev->source.subsys.u.pci.function); + virPCIDevicePtr pci = + virPCIDeviceNew(dev->source.subsys.u.pci.domain, + dev->source.subsys.u.pci.bus, + dev->source.subsys.u.pci.slot, + dev->source.subsys.u.pci.function); if (!pci) goto done; - ret = pciDeviceFileIterate(pci, virSecuritySELinuxSetSecurityPCILabel, def); - pciFreeDevice(pci); + ret = virPCIDeviceFileIterate(pci, virSecuritySELinuxSetSecurityPCILabel, def); + virPCIDeviceFree(pci); break; } @@ -1326,7 +1327,7 @@ virSecuritySELinuxSetSecurityHostdevLabel(virSecurityManagerPtr mgr ATTRIBUTE_UN static int -virSecuritySELinuxRestoreSecurityPCILabel(pciDevice *dev ATTRIBUTE_UNUSED, +virSecuritySELinuxRestoreSecurityPCILabel(virPCIDevicePtr dev ATTRIBUTE_UNUSED, const char *file, void *opaque) { @@ -1374,16 +1375,17 @@ virSecuritySELinuxRestoreSecurityHostdevSubsysLabel(virSecurityManagerPtr mgr, } case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: { - pciDevice *pci = pciGetDevice(dev->source.subsys.u.pci.domain, - dev->source.subsys.u.pci.bus, - dev->source.subsys.u.pci.slot, - dev->source.subsys.u.pci.function); + virPCIDevicePtr pci = + virPCIDeviceNew(dev->source.subsys.u.pci.domain, + dev->source.subsys.u.pci.bus, + dev->source.subsys.u.pci.slot, + dev->source.subsys.u.pci.function); if (!pci) goto done; - ret = pciDeviceFileIterate(pci, virSecuritySELinuxRestoreSecurityPCILabel, mgr); - pciFreeDevice(pci); + ret = virPCIDeviceFileIterate(pci, virSecuritySELinuxRestoreSecurityPCILabel, mgr); + virPCIDeviceFree(pci); break; } diff --git a/src/security/virt-aa-helper.c b/src/security/virt-aa-helper.c index 0aa978e..227d0f1 100644 --- a/src/security/virt-aa-helper.c +++ b/src/security/virt-aa-helper.c @@ -853,8 +853,8 @@ file_iterate_hostdev_cb(usbDevice *dev ATTRIBUTE_UNUSED, } static int -file_iterate_pci_cb(pciDevice *dev ATTRIBUTE_UNUSED, - const char *file, void *opaque) +file_iterate_pci_cb(virPCIDevicePtr dev ATTRIBUTE_UNUSED, + const char *file, void *opaque) { virBufferPtr buf = opaque; return vah_add_file(buf, file, "rw"); @@ -1022,7 +1022,7 @@ get_files(vahControl * ctl) } case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI: { - pciDevice *pci = pciGetDevice( + virPCIDevicePtr pci = virPCIDeviceNew( dev->source.subsys.u.pci.domain, dev->source.subsys.u.pci.bus, dev->source.subsys.u.pci.slot, @@ -1031,8 +1031,8 @@ get_files(vahControl * ctl) if (pci == NULL) continue; - rc = pciDeviceFileIterate(pci, file_iterate_pci_cb, &buf); - pciFreeDevice(pci); + rc = virPCIDeviceFileIterate(pci, file_iterate_pci_cb, &buf); + virPCIDeviceFree(pci); break; } diff --git a/src/util/virnetdev.c b/src/util/virnetdev.c index 295884f..296871c 100644 --- a/src/util/virnetdev.c +++ b/src/util/virnetdev.c @@ -980,7 +980,7 @@ virNetDevSysfsDeviceFile(char **pf_sysfs_device_link, const char *ifname, int virNetDevGetVirtualFunctions(const char *pfname, char ***vfname, - struct pci_config_address ***virt_fns, + virPCIDeviceAddressPtr **virt_fns, unsigned int *n_vfname) { int ret = -1, i; @@ -991,8 +991,8 @@ virNetDevGetVirtualFunctions(const char *pfname, if (virNetDevSysfsFile(&pf_sysfs_device_link, pfname, "device") < 0) return ret; - if (pciGetVirtualFunctions(pf_sysfs_device_link, virt_fns, - n_vfname) < 0) + if (virPCIGetVirtualFunctions(pf_sysfs_device_link, virt_fns, + n_vfname) < 0) goto cleanup; if (VIR_ALLOC_N(*vfname, *n_vfname) < 0) { @@ -1002,22 +1002,22 @@ virNetDevGetVirtualFunctions(const char *pfname, for (i = 0; i < *n_vfname; i++) { - if (pciGetDeviceAddrString((*virt_fns)[i]->domain, - (*virt_fns)[i]->bus, - (*virt_fns)[i]->slot, - (*virt_fns)[i]->function, - &pciConfigAddr) < 0) { + if (virPCIGetAddrString((*virt_fns)[i]->domain, + (*virt_fns)[i]->bus, + (*virt_fns)[i]->slot, + (*virt_fns)[i]->function, + &pciConfigAddr) < 0) { virReportSystemError(ENOSYS, "%s", _("Failed to get PCI Config Address String")); goto cleanup; } - if (pciSysfsFile(pciConfigAddr, &pci_sysfs_device_link) < 0) { + if (virPCIGetSysfsFile(pciConfigAddr, &pci_sysfs_device_link) < 0) { virReportSystemError(ENOSYS, "%s", _("Failed to get PCI SYSFS file")); goto cleanup; } - if (pciDeviceNetName(pci_sysfs_device_link, &((*vfname)[i])) < 0) { + if (virPCIGetNetName(pci_sysfs_device_link, &((*vfname)[i])) < 0) { VIR_INFO("VF does not have an interface name"); } } @@ -1053,7 +1053,7 @@ virNetDevIsVirtualFunction(const char *ifname) if (virNetDevSysfsFile(&if_sysfs_device_link, ifname, "device") < 0) return ret; - ret = pciDeviceIsVirtualFunction(if_sysfs_device_link); + ret = virPCIIsVirtualFunction(if_sysfs_device_link); VIR_FREE(if_sysfs_device_link); @@ -1086,9 +1086,9 @@ virNetDevGetVirtualFunctionIndex(const char *pfname, const char *vfname, return ret; } - ret = pciGetVirtualFunctionIndex(pf_sysfs_device_link, - vf_sysfs_device_link, - vf_index); + ret = virPCIGetVirtualFunctionIndex(pf_sysfs_device_link, + vf_sysfs_device_link, + vf_index); VIR_FREE(pf_sysfs_device_link); VIR_FREE(vf_sysfs_device_link); @@ -1115,7 +1115,7 @@ virNetDevGetPhysicalFunction(const char *ifname, char **pfname) if (virNetDevSysfsDeviceFile(&physfn_sysfs_path, ifname, "physfn") < 0) return ret; - ret = pciDeviceNetName(physfn_sysfs_path, pfname); + ret = virPCIGetNetName(physfn_sysfs_path, pfname); VIR_FREE(physfn_sysfs_path); @@ -1149,7 +1149,7 @@ virNetDevGetVirtualFunctionInfo(const char *vfname, char **pfname, if (virNetDevSysfsFile(&vf_sysfs_path, vfname, "device") < 0) goto cleanup; - ret = pciGetVirtualFunctionIndex(pf_sysfs_path, vf_sysfs_path, vf); + ret = virPCIGetVirtualFunctionIndex(pf_sysfs_path, vf_sysfs_path, vf); cleanup: if (ret < 0) @@ -1165,7 +1165,7 @@ cleanup: int virNetDevGetVirtualFunctions(const char *pfname ATTRIBUTE_UNUSED, char ***vfname ATTRIBUTE_UNUSED, - struct pci_config_address ***virt_fns ATTRIBUTE_UNUSED, + virPCIDeviceAddressPtr **virt_fns ATTRIBUTE_UNUSED, unsigned int *n_vfname ATTRIBUTE_UNUSED) { virReportSystemError(ENOSYS, "%s", diff --git a/src/util/virnetdev.h b/src/util/virnetdev.h index d588e89..06d0650 100644 --- a/src/util/virnetdev.h +++ b/src/util/virnetdev.h @@ -104,7 +104,7 @@ int virNetDevGetPhysicalFunction(const char *ifname, char **pfname) int virNetDevGetVirtualFunctions(const char *pfname, char ***vfname, - struct pci_config_address ***virt_fns, + virPCIDeviceAddressPtr **virt_fns, unsigned int *n_vfname) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK; diff --git a/src/util/virpci.c b/src/util/virpci.c index 0fb9923..695f372 100644 --- a/src/util/virpci.c +++ b/src/util/virpci.c @@ -50,7 +50,7 @@ #define SRIOV_NOT_FOUND 1 #define SRIOV_ERROR -1 -struct _pciDevice { +struct _virPCIDevice { unsigned domain; unsigned bus; unsigned slot; @@ -73,9 +73,9 @@ struct _pciDevice { unsigned reprobe : 1; }; -struct _pciDeviceList { +struct _virPCIDeviceList { unsigned count; - pciDevice **devs; + virPCIDevicePtr *devs; }; @@ -160,13 +160,13 @@ struct _pciDeviceList { #define PCI_EXT_CAP_ACS_RR 0x04 #define PCI_EXT_CAP_ACS_CR 0x08 #define PCI_EXT_CAP_ACS_UF 0x10 -#define PCI_EXT_CAP_ACS_ENABLED (PCI_EXT_CAP_ACS_SV | \ - PCI_EXT_CAP_ACS_RR | \ - PCI_EXT_CAP_ACS_CR | \ +#define PCI_EXT_CAP_ACS_ENABLED (PCI_EXT_CAP_ACS_SV | \ + PCI_EXT_CAP_ACS_RR | \ + PCI_EXT_CAP_ACS_CR | \ PCI_EXT_CAP_ACS_UF) static int -pciConfigOpen(pciDevice *dev, bool fatal) +virPCIDeviceConfigOpen(virPCIDevicePtr dev, bool fatal) { int fd; @@ -190,7 +190,7 @@ pciConfigOpen(pciDevice *dev, bool fatal) } static void -pciConfigClose(pciDevice *dev, int cfgfd) +virPCIDeviceConfigClose(virPCIDevicePtr dev, int cfgfd) { if (VIR_CLOSE(cfgfd) < 0) { char ebuf[1024]; @@ -201,11 +201,11 @@ pciConfigClose(pciDevice *dev, int cfgfd) static int -pciRead(pciDevice *dev, - int cfgfd, - unsigned pos, - uint8_t *buf, - unsigned buflen) +virPCIDeviceRead(virPCIDevicePtr dev, + int cfgfd, + unsigned pos, + uint8_t *buf, + unsigned buflen) { memset(buf, 0, buflen); @@ -220,35 +220,35 @@ pciRead(pciDevice *dev, } static uint8_t -pciRead8(pciDevice *dev, int cfgfd, unsigned pos) +virPCIDeviceRead8(virPCIDevicePtr dev, int cfgfd, unsigned pos) { uint8_t buf; - pciRead(dev, cfgfd, pos, &buf, sizeof(buf)); + virPCIDeviceRead(dev, cfgfd, pos, &buf, sizeof(buf)); return buf; } static uint16_t -pciRead16(pciDevice *dev, int cfgfd, unsigned pos) +virPCIDeviceRead16(virPCIDevicePtr dev, int cfgfd, unsigned pos) { uint8_t buf[2]; - pciRead(dev, cfgfd, pos, &buf[0], sizeof(buf)); + virPCIDeviceRead(dev, cfgfd, pos, &buf[0], sizeof(buf)); return (buf[0] << 0) | (buf[1] << 8); } static uint32_t -pciRead32(pciDevice *dev, int cfgfd, unsigned pos) +virPCIDeviceRead32(virPCIDevicePtr dev, int cfgfd, unsigned pos) { uint8_t buf[4]; - pciRead(dev, cfgfd, pos, &buf[0], sizeof(buf)); + virPCIDeviceRead(dev, cfgfd, pos, &buf[0], sizeof(buf)); return (buf[0] << 0) | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); } static int -pciWrite(pciDevice *dev, - int cfgfd, - unsigned pos, - uint8_t *buf, - unsigned buflen) +virPCIDeviceWrite(virPCIDevicePtr dev, + int cfgfd, + unsigned pos, + uint8_t *buf, + unsigned buflen) { if (lseek(cfgfd, pos, SEEK_SET) != pos || safewrite(cfgfd, buf, buflen) != buflen) { @@ -261,20 +261,20 @@ pciWrite(pciDevice *dev, } static void -pciWrite16(pciDevice *dev, int cfgfd, unsigned pos, uint16_t val) +virPCIDeviceWrite16(virPCIDevicePtr dev, int cfgfd, unsigned pos, uint16_t val) { uint8_t buf[2] = { (val >> 0), (val >> 8) }; - pciWrite(dev, cfgfd, pos, &buf[0], sizeof(buf)); + virPCIDeviceWrite(dev, cfgfd, pos, &buf[0], sizeof(buf)); } static void -pciWrite32(pciDevice *dev, int cfgfd, unsigned pos, uint32_t val) +virPCIDeviceWrite32(virPCIDevicePtr dev, int cfgfd, unsigned pos, uint32_t val) { uint8_t buf[4] = { (val >> 0), (val >> 8), (val >> 16), (val >> 24) }; - pciWrite(dev, cfgfd, pos, &buf[0], sizeof(buf)); + virPCIDeviceWrite(dev, cfgfd, pos, &buf[0], sizeof(buf)); } -typedef int (*pciIterPredicate)(pciDevice *, pciDevice *, void *); +typedef int (*virPCIDeviceIterPredicate)(virPCIDevicePtr , virPCIDevicePtr , void *); /* Iterate over available PCI devices calling @predicate * to compare each one to @dev. @@ -282,10 +282,10 @@ typedef int (*pciIterPredicate)(pciDevice *, pciDevice *, void *); * safe to reset if there is an error. */ static int -pciIterDevices(pciIterPredicate predicate, - pciDevice *dev, - pciDevice **matched, - void *data) +virPCIDeviceIterDevices(virPCIDeviceIterPredicate predicate, + virPCIDevicePtr dev, + virPCIDevicePtr *matched, + void *data) { DIR *dir; struct dirent *entry; @@ -304,7 +304,7 @@ pciIterDevices(pciIterPredicate predicate, while ((entry = readdir(dir))) { unsigned int domain, bus, slot, function; - pciDevice *check; + virPCIDevicePtr check; char *tmp; /* Ignore '.' and '..' */ @@ -324,7 +324,7 @@ pciIterDevices(pciIterPredicate predicate, continue; } - check = pciGetDevice(domain, bus, slot, function); + check = virPCIDeviceNew(domain, bus, slot, function); if (!check) { ret = -1; break; @@ -333,7 +333,7 @@ pciIterDevices(pciIterPredicate predicate, rc = predicate(dev, check, data); if (rc < 0) { /* the predicate returned an error, bail */ - pciFreeDevice(check); + virPCIDeviceFree(check); ret = -1; break; } @@ -344,23 +344,23 @@ pciIterDevices(pciIterPredicate predicate, break; } - pciFreeDevice(check); + virPCIDeviceFree(check); } closedir(dir); return ret; } static uint8_t -pciFindCapabilityOffset(pciDevice *dev, int cfgfd, unsigned capability) +virPCIDeviceFindCapabilityOffset(virPCIDevicePtr dev, int cfgfd, unsigned capability) { uint16_t status; uint8_t pos; - status = pciRead16(dev, cfgfd, PCI_STATUS); + status = virPCIDeviceRead16(dev, cfgfd, PCI_STATUS); if (!(status & PCI_STATUS_CAP_LIST)) return 0; - pos = pciRead8(dev, cfgfd, PCI_CAPABILITY_LIST); + pos = virPCIDeviceRead8(dev, cfgfd, PCI_CAPABILITY_LIST); /* Zero indicates last capability, capabilities can't * be in the config space header and 0xff is returned @@ -370,14 +370,14 @@ pciFindCapabilityOffset(pciDevice *dev, int cfgfd, unsigned capability) * capabilities here. */ while (pos >= PCI_CONF_HEADER_LEN && pos != 0xff) { - uint8_t capid = pciRead8(dev, cfgfd, pos); + uint8_t capid = virPCIDeviceRead8(dev, cfgfd, pos); if (capid == capability) { VIR_DEBUG("%s %s: found cap 0x%.2x at 0x%.2x", dev->id, dev->name, capability, pos); return pos; } - pos = pciRead8(dev, cfgfd, pos + 1); + pos = virPCIDeviceRead8(dev, cfgfd, pos + 1); } VIR_DEBUG("%s %s: failed to find cap 0x%.2x", dev->id, dev->name, capability); @@ -386,9 +386,9 @@ pciFindCapabilityOffset(pciDevice *dev, int cfgfd, unsigned capability) } static unsigned int -pciFindExtendedCapabilityOffset(pciDevice *dev, - int cfgfd, - unsigned capability) +virPCIDeviceFindExtendedCapabilityOffset(virPCIDevicePtr dev, + int cfgfd, + unsigned capability) { int ttl; unsigned int pos; @@ -399,7 +399,7 @@ pciFindExtendedCapabilityOffset(pciDevice *dev, pos = PCI_EXT_CAP_BASE; while (ttl > 0 && pos >= PCI_EXT_CAP_BASE) { - header = pciRead32(dev, cfgfd, pos); + header = virPCIDeviceRead32(dev, cfgfd, pos); if ((header & PCI_EXT_CAP_ID_MASK) == capability) return pos; @@ -415,7 +415,7 @@ pciFindExtendedCapabilityOffset(pciDevice *dev, * not have FLR, 1 if it does, and -1 on error */ static int -pciDetectFunctionLevelReset(pciDevice *dev, int cfgfd) +virPCIDeviceDetectFunctionLevelReset(virPCIDevicePtr dev, int cfgfd) { uint32_t caps; uint8_t pos; @@ -429,7 +429,7 @@ pciDetectFunctionLevelReset(pciDevice *dev, int cfgfd) * on SR-IOV NICs at the moment. */ if (dev->pcie_cap_pos) { - caps = pciRead32(dev, cfgfd, dev->pcie_cap_pos + PCI_EXP_DEVCAP); + caps = virPCIDeviceRead32(dev, cfgfd, dev->pcie_cap_pos + PCI_EXP_DEVCAP); if (caps & PCI_EXP_DEVCAP_FLR) { VIR_DEBUG("%s %s: detected PCIe FLR capability", dev->id, dev->name); return 1; @@ -440,9 +440,9 @@ pciDetectFunctionLevelReset(pciDevice *dev, int cfgfd) * the same thing, except for conventional PCI * devices. This is not common yet. */ - pos = pciFindCapabilityOffset(dev, cfgfd, PCI_CAP_ID_AF); + pos = virPCIDeviceFindCapabilityOffset(dev, cfgfd, PCI_CAP_ID_AF); if (pos) { - caps = pciRead16(dev, cfgfd, pos + PCI_AF_CAP); + caps = virPCIDeviceRead16(dev, cfgfd, pos + PCI_AF_CAP); if (caps & PCI_AF_CAP_FLR) { VIR_DEBUG("%s %s: detected PCI FLR capability", dev->id, dev->name); return 1; @@ -478,13 +478,13 @@ pciDetectFunctionLevelReset(pciDevice *dev, int cfgfd) * internal reset, not just a soft reset. */ static unsigned -pciDetectPowerManagementReset(pciDevice *dev, int cfgfd) +virPCIDeviceDetectPowerManagementReset(virPCIDevicePtr dev, int cfgfd) { if (dev->pci_pm_cap_pos) { uint32_t ctl; /* require the NO_SOFT_RESET bit is clear */ - ctl = pciRead32(dev, cfgfd, dev->pci_pm_cap_pos + PCI_PM_CTRL); + ctl = virPCIDeviceRead32(dev, cfgfd, dev->pci_pm_cap_pos + PCI_PM_CTRL); if (!(ctl & PCI_PM_CTRL_NO_SOFT_RESET)) { VIR_DEBUG("%s %s: detected PM reset capability", dev->id, dev->name); return 1; @@ -498,9 +498,9 @@ pciDetectPowerManagementReset(pciDevice *dev, int cfgfd) /* Any active devices on the same domain/bus ? */ static int -pciSharesBusWithActive(pciDevice *dev, pciDevice *check, void *data) +virPCIDeviceSharesBusWithActive(virPCIDevicePtr dev, virPCIDevicePtr check, void *data) { - pciDeviceList *inactiveDevs = data; + virPCIDeviceList *inactiveDevs = data; /* Different domain, different bus, or simply identical device */ if (dev->domain != check->domain || @@ -510,51 +510,51 @@ pciSharesBusWithActive(pciDevice *dev, pciDevice *check, void *data) return 0; /* same bus, but inactive, i.e. about to be assigned to guest */ - if (inactiveDevs && pciDeviceListFind(inactiveDevs, check)) + if (inactiveDevs && virPCIDeviceListFind(inactiveDevs, check)) return 0; return 1; } -static pciDevice * -pciBusContainsActiveDevices(pciDevice *dev, - pciDeviceList *inactiveDevs) +static virPCIDevicePtr +virPCIDeviceBusContainsActiveDevices(virPCIDevicePtr dev, + virPCIDeviceList *inactiveDevs) { - pciDevice *active = NULL; - if (pciIterDevices(pciSharesBusWithActive, - dev, &active, inactiveDevs) < 0) + virPCIDevicePtr active = NULL; + if (virPCIDeviceIterDevices(virPCIDeviceSharesBusWithActive, + dev, &active, inactiveDevs) < 0) return NULL; return active; } /* Is @check the parent of @dev ? */ static int -pciIsParent(pciDevice *dev, pciDevice *check, void *data) +virPCIDeviceIsParent(virPCIDevicePtr dev, virPCIDevicePtr check, void *data) { uint16_t device_class; uint8_t header_type, secondary, subordinate; - pciDevice **best = data; + virPCIDevicePtr *best = data; int ret = 0; int fd; if (dev->domain != check->domain) return 0; - if ((fd = pciConfigOpen(check, false)) < 0) + if ((fd = virPCIDeviceConfigOpen(check, false)) < 0) return 0; /* Is it a bridge? */ - device_class = pciRead16(check, fd, PCI_CLASS_DEVICE); + device_class = virPCIDeviceRead16(check, fd, PCI_CLASS_DEVICE); if (device_class != PCI_CLASS_BRIDGE_PCI) goto cleanup; /* Is it a plane? */ - header_type = pciRead8(check, fd, PCI_HEADER_TYPE); + header_type = virPCIDeviceRead8(check, fd, PCI_HEADER_TYPE); if ((header_type & PCI_HEADER_TYPE_MASK) != PCI_HEADER_TYPE_BRIDGE) goto cleanup; - secondary = pciRead8(check, fd, PCI_SECONDARY_BUS); - subordinate = pciRead8(check, fd, PCI_SUBORDINATE_BUS); + secondary = virPCIDeviceRead8(check, fd, PCI_SECONDARY_BUS); + subordinate = virPCIDeviceRead8(check, fd, PCI_SUBORDINATE_BUS); VIR_DEBUG("%s %s: found parent device %s", dev->id, dev->name, check->name); @@ -572,8 +572,8 @@ pciIsParent(pciDevice *dev, pciDevice *check, void *data) */ if (dev->bus > secondary && dev->bus <= subordinate) { if (*best == NULL) { - *best = pciGetDevice(check->domain, check->bus, check->slot, - check->function); + *best = virPCIDeviceNew(check->domain, check->bus, check->slot, + check->function); if (*best == NULL) { ret = -1; goto cleanup; @@ -586,15 +586,15 @@ pciIsParent(pciDevice *dev, pciDevice *check, void *data) int bestfd; uint8_t best_secondary; - if ((bestfd = pciConfigOpen(*best, false)) < 0) + if ((bestfd = virPCIDeviceConfigOpen(*best, false)) < 0) goto cleanup; - best_secondary = pciRead8(*best, bestfd, PCI_SECONDARY_BUS); - pciConfigClose(*best, bestfd); + best_secondary = virPCIDeviceRead8(*best, bestfd, PCI_SECONDARY_BUS); + virPCIDeviceConfigClose(*best, bestfd); if (secondary > best_secondary) { - pciFreeDevice(*best); - *best = pciGetDevice(check->domain, check->bus, check->slot, - check->function); + virPCIDeviceFree(*best); + *best = virPCIDeviceNew(check->domain, check->bus, check->slot, + check->function); if (*best == NULL) { ret = -1; goto cleanup; @@ -604,20 +604,20 @@ pciIsParent(pciDevice *dev, pciDevice *check, void *data) } cleanup: - pciConfigClose(check, fd); + virPCIDeviceConfigClose(check, fd); return ret; } static int -pciGetParentDevice(pciDevice *dev, pciDevice **parent) +virPCIDeviceGetParentDevice(virPCIDevicePtr dev, virPCIDevicePtr *parent) { - pciDevice *best = NULL; + virPCIDevicePtr best = NULL; int ret; *parent = NULL; - ret = pciIterDevices(pciIsParent, dev, parent, &best); + ret = virPCIDeviceIterDevices(virPCIDeviceIsParent, dev, parent, &best); if (ret == 1) - pciFreeDevice(best); + virPCIDeviceFree(best); else if (ret == 0) *parent = best; return ret; @@ -627,11 +627,11 @@ pciGetParentDevice(pciDevice *dev, pciDevice **parent) * devices behind a bus. */ static int -pciTrySecondaryBusReset(pciDevice *dev, - int cfgfd, - pciDeviceList *inactiveDevs) +virPCIDeviceTrySecondaryBusReset(virPCIDevicePtr dev, + int cfgfd, + virPCIDeviceList *inactiveDevs) { - pciDevice *parent, *conflict; + virPCIDevicePtr parent, conflict; uint8_t config_space[PCI_CONF_LEN]; uint16_t ctl; int ret = -1; @@ -641,7 +641,7 @@ pciTrySecondaryBusReset(pciDevice *dev, * devices/functions behind the bus are used by the host * or other guests. */ - if ((conflict = pciBusContainsActiveDevices(dev, inactiveDevs))) { + if ((conflict = virPCIDeviceBusContainsActiveDevices(dev, inactiveDevs))) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Active %s devices on bus with %s, not doing bus reset"), conflict->name, dev->name); @@ -649,7 +649,7 @@ pciTrySecondaryBusReset(pciDevice *dev, } /* Find the parent bus */ - if (pciGetParentDevice(dev, &parent) < 0) + if (virPCIDeviceGetParentDevice(dev, &parent) < 0) return -1; if (!parent) { virReportError(VIR_ERR_INTERNAL_ERROR, @@ -657,7 +657,7 @@ pciTrySecondaryBusReset(pciDevice *dev, dev->name); return -1; } - if ((parentfd = pciConfigOpen(parent, true)) < 0) + if ((parentfd = virPCIDeviceConfigOpen(parent, true)) < 0) goto out; VIR_DEBUG("%s %s: doing a secondary bus reset", dev->id, dev->name); @@ -666,7 +666,7 @@ pciTrySecondaryBusReset(pciDevice *dev, * for the supplied device since we refuse to do a reset if there * are multiple devices/functions */ - if (pciRead(dev, cfgfd, 0, config_space, PCI_CONF_LEN) < 0) { + if (virPCIDeviceRead(dev, cfgfd, 0, config_space, PCI_CONF_LEN) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to read PCI config space for %s"), dev->name); @@ -676,18 +676,18 @@ pciTrySecondaryBusReset(pciDevice *dev, /* Read the control register, set the reset flag, wait 200ms, * unset the reset flag and wait 200ms. */ - ctl = pciRead16(dev, cfgfd, PCI_BRIDGE_CONTROL); + ctl = virPCIDeviceRead16(dev, cfgfd, PCI_BRIDGE_CONTROL); - pciWrite16(parent, parentfd, PCI_BRIDGE_CONTROL, - ctl | PCI_BRIDGE_CTL_RESET); + virPCIDeviceWrite16(parent, parentfd, PCI_BRIDGE_CONTROL, + ctl | PCI_BRIDGE_CTL_RESET); usleep(200 * 1000); /* sleep 200ms */ - pciWrite16(parent, parentfd, PCI_BRIDGE_CONTROL, ctl); + virPCIDeviceWrite16(parent, parentfd, PCI_BRIDGE_CONTROL, ctl); usleep(200 * 1000); /* sleep 200ms */ - if (pciWrite(dev, cfgfd, 0, config_space, PCI_CONF_LEN) < 0) { + if (virPCIDeviceWrite(dev, cfgfd, 0, config_space, PCI_CONF_LEN) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to restore PCI config space for %s"), dev->name); @@ -696,8 +696,8 @@ pciTrySecondaryBusReset(pciDevice *dev, ret = 0; out: - pciConfigClose(parent, parentfd); - pciFreeDevice(parent); + virPCIDeviceConfigClose(parent, parentfd); + virPCIDeviceFree(parent); return ret; } @@ -706,7 +706,7 @@ out: * above we require the device supports a full internal reset. */ static int -pciTryPowerManagementReset(pciDevice *dev, int cfgfd) +virPCIDeviceTryPowerManagementReset(virPCIDevicePtr dev, int cfgfd) { uint8_t config_space[PCI_CONF_LEN]; uint32_t ctl; @@ -715,7 +715,7 @@ pciTryPowerManagementReset(pciDevice *dev, int cfgfd) return -1; /* Save and restore the device's config space. */ - if (pciRead(dev, cfgfd, 0, &config_space[0], PCI_CONF_LEN) < 0) { + if (virPCIDeviceRead(dev, cfgfd, 0, &config_space[0], PCI_CONF_LEN) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to read PCI config space for %s"), dev->name); @@ -724,20 +724,20 @@ pciTryPowerManagementReset(pciDevice *dev, int cfgfd) VIR_DEBUG("%s %s: doing a power management reset", dev->id, dev->name); - ctl = pciRead32(dev, cfgfd, dev->pci_pm_cap_pos + PCI_PM_CTRL); + ctl = virPCIDeviceRead32(dev, cfgfd, dev->pci_pm_cap_pos + PCI_PM_CTRL); ctl &= ~PCI_PM_CTRL_STATE_MASK; - pciWrite32(dev, cfgfd, dev->pci_pm_cap_pos + PCI_PM_CTRL, - ctl | PCI_PM_CTRL_STATE_D3hot); + virPCIDeviceWrite32(dev, cfgfd, dev->pci_pm_cap_pos + PCI_PM_CTRL, + ctl | PCI_PM_CTRL_STATE_D3hot); usleep(10 * 1000); /* sleep 10ms */ - pciWrite32(dev, cfgfd, dev->pci_pm_cap_pos + PCI_PM_CTRL, - ctl | PCI_PM_CTRL_STATE_D0); + virPCIDeviceWrite32(dev, cfgfd, dev->pci_pm_cap_pos + PCI_PM_CTRL, + ctl | PCI_PM_CTRL_STATE_D0); usleep(10 * 1000); /* sleep 10ms */ - if (pciWrite(dev, cfgfd, 0, &config_space[0], PCI_CONF_LEN) < 0) { + if (virPCIDeviceWrite(dev, cfgfd, 0, &config_space[0], PCI_CONF_LEN) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to restore PCI config space for %s"), dev->name); @@ -748,39 +748,39 @@ pciTryPowerManagementReset(pciDevice *dev, int cfgfd) } static int -pciInitDevice(pciDevice *dev, int cfgfd) +virPCIDeviceInitDevice(virPCIDevicePtr dev, int cfgfd) { int flr; - dev->pcie_cap_pos = pciFindCapabilityOffset(dev, cfgfd, PCI_CAP_ID_EXP); - dev->pci_pm_cap_pos = pciFindCapabilityOffset(dev, cfgfd, PCI_CAP_ID_PM); - flr = pciDetectFunctionLevelReset(dev, cfgfd); + dev->pcie_cap_pos = virPCIDeviceFindCapabilityOffset(dev, cfgfd, PCI_CAP_ID_EXP); + dev->pci_pm_cap_pos = virPCIDeviceFindCapabilityOffset(dev, cfgfd, PCI_CAP_ID_PM); + flr = virPCIDeviceDetectFunctionLevelReset(dev, cfgfd); if (flr < 0) return flr; dev->has_flr = flr; - dev->has_pm_reset = pciDetectPowerManagementReset(dev, cfgfd); + dev->has_pm_reset = virPCIDeviceDetectPowerManagementReset(dev, cfgfd); return 0; } int -pciResetDevice(pciDevice *dev, - pciDeviceList *activeDevs, - pciDeviceList *inactiveDevs) +virPCIDeviceReset(virPCIDevicePtr dev, + virPCIDeviceList *activeDevs, + virPCIDeviceList *inactiveDevs) { int ret = -1; int fd; - if (activeDevs && pciDeviceListFind(activeDevs, dev)) { + if (activeDevs && virPCIDeviceListFind(activeDevs, dev)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Not resetting active device %s"), dev->name); return -1; } - if ((fd = pciConfigOpen(dev, true)) < 0) + if ((fd = virPCIDeviceConfigOpen(dev, true)) < 0) return -1; - if (pciInitDevice(dev, fd) < 0) + if (virPCIDeviceInitDevice(dev, fd) < 0) goto cleanup; /* KVM will perform FLR when starting and stopping @@ -796,11 +796,11 @@ pciResetDevice(pciDevice *dev, * the function, not the whole device. */ if (dev->has_pm_reset) - ret = pciTryPowerManagementReset(dev, fd); + ret = virPCIDeviceTryPowerManagementReset(dev, fd); /* Bus reset is not an option with the root bus */ if (ret < 0 && dev->bus != 0) - ret = pciTrySecondaryBusReset(dev, fd, inactiveDevs); + ret = virPCIDeviceTrySecondaryBusReset(dev, fd, inactiveDevs); if (ret < 0) { virErrorPtr err = virGetLastError(); @@ -811,13 +811,13 @@ pciResetDevice(pciDevice *dev, } cleanup: - pciConfigClose(dev, fd); + virPCIDeviceConfigClose(dev, fd); return ret; } static int -pciDriverDir(char **buffer, const char *driver) +virPCIDriverDir(char **buffer, const char *driver) { VIR_FREE(*buffer); @@ -830,7 +830,7 @@ pciDriverDir(char **buffer, const char *driver) } static int -pciDriverFile(char **buffer, const char *driver, const char *file) +virPCIDriverFile(char **buffer, const char *driver, const char *file) { VIR_FREE(*buffer); @@ -843,7 +843,7 @@ pciDriverFile(char **buffer, const char *driver, const char *file) } static int -pciDeviceFile(char **buffer, const char *device, const char *file) +virPCIFile(char **buffer, const char *device, const char *file) { VIR_FREE(*buffer); @@ -856,13 +856,13 @@ pciDeviceFile(char **buffer, const char *device, const char *file) } static int -pciProbeStubDriver(const char *driver) +virPCIProbeStubDriver(const char *driver) { char *drvpath = NULL; int probed = 0; recheck: - if (pciDriverDir(&drvpath, driver) == 0 && virFileExists(drvpath)) { + if (virPCIDriverDir(&drvpath, driver) == 0 && virFileExists(drvpath)) { /* driver already loaded, return */ VIR_FREE(drvpath); return 0; @@ -887,13 +887,13 @@ recheck: } static int -pciUnbindDeviceFromStub(pciDevice *dev, const char *driver) +virPCIDeviceUnbindDeviceFromStub(virPCIDevicePtr dev, const char *driver) { int result = -1; char *drvdir = NULL; char *path = NULL; - if (pciDriverDir(&drvdir, driver) < 0) + if (virPCIDriverDir(&drvdir, driver) < 0) goto cleanup; if (!dev->unbind_from_stub) @@ -901,11 +901,11 @@ pciUnbindDeviceFromStub(pciDevice *dev, const char *driver) /* If the device is bound to stub, unbind it. */ - if (pciDeviceFile(&path, dev->name, "driver") < 0) + if (virPCIFile(&path, dev->name, "driver") < 0) goto cleanup; if (virFileExists(drvdir) && virFileLinkPointsTo(path, drvdir)) { - if (pciDriverFile(&path, driver, "unbind") < 0) { + if (virPCIDriverFile(&path, driver, "unbind") < 0) { goto cleanup; } @@ -923,7 +923,7 @@ remove_slot: goto reprobe; /* Xen's pciback.ko wants you to use remove_slot on the specific device */ - if (pciDriverFile(&path, driver, "remove_slot") < 0) { + if (virPCIDriverFile(&path, driver, "remove_slot") < 0) { goto cleanup; } @@ -946,7 +946,7 @@ reprobe: * available, then re-probing would just cause the device to be * re-bound to the stub. */ - if (pciDriverFile(&path, driver, "remove_id") < 0) { + if (virPCIDriverFile(&path, driver, "remove_id") < 0) { goto cleanup; } @@ -975,7 +975,7 @@ cleanup: static int -pciBindDeviceToStub(pciDevice *dev, const char *driver) +virPCIDeviceBindDeviceToStub(virPCIDevicePtr dev, const char *driver) { int result = -1; char *drvdir = NULL; @@ -983,8 +983,8 @@ pciBindDeviceToStub(pciDevice *dev, const char *driver) int reprobe = 0; /* check whether the device is already bound to a driver */ - if (pciDriverDir(&drvdir, driver) < 0 || - pciDeviceFile(&path, dev->name, "driver") < 0) { + if (virPCIDriverDir(&drvdir, driver) < 0 || + virPCIFile(&path, dev->name, "driver") < 0) { goto cleanup; } @@ -1005,7 +1005,7 @@ pciBindDeviceToStub(pciDevice *dev, const char *driver) * is triggered for such a device, it will also be immediately * bound by the stub. */ - if (pciDriverFile(&path, driver, "new_id") < 0) { + if (virPCIDriverFile(&path, driver, "new_id") < 0) { goto cleanup; } @@ -1019,8 +1019,8 @@ pciBindDeviceToStub(pciDevice *dev, const char *driver) /* check whether the device is bound to pci-stub when we write dev->id to * new_id. */ - if (pciDriverDir(&drvdir, driver) < 0 || - pciDeviceFile(&path, dev->name, "driver") < 0) { + if (virPCIDriverDir(&drvdir, driver) < 0 || + virPCIFile(&path, dev->name, "driver") < 0) { goto remove_id; } @@ -1035,7 +1035,7 @@ pciBindDeviceToStub(pciDevice *dev, const char *driver) * PCI device happens to be IDE controller for the disk hosting * your root filesystem. */ - if (pciDeviceFile(&path, dev->name, "driver/unbind") < 0) { + if (virPCIFile(&path, dev->name, "driver/unbind") < 0) { goto cleanup; } @@ -1051,14 +1051,14 @@ pciBindDeviceToStub(pciDevice *dev, const char *driver) /* If the device isn't already bound to pci-stub, try binding it now. */ - if (pciDriverDir(&drvdir, driver) < 0 || - pciDeviceFile(&path, dev->name, "driver") < 0) { + if (virPCIDriverDir(&drvdir, driver) < 0 || + virPCIFile(&path, dev->name, "driver") < 0) { goto remove_id; } if (!virFileLinkPointsTo(path, drvdir)) { /* Xen's pciback.ko wants you to use new_slot first */ - if (pciDriverFile(&path, driver, "new_slot") < 0) { + if (virPCIDriverFile(&path, driver, "new_slot") < 0) { goto remove_id; } @@ -1070,7 +1070,7 @@ pciBindDeviceToStub(pciDevice *dev, const char *driver) } dev->remove_slot = 1; - if (pciDriverFile(&path, driver, "bind") < 0) { + if (virPCIDriverFile(&path, driver, "bind") < 0) { goto remove_id; } @@ -1087,7 +1087,7 @@ remove_id: /* If 'remove_id' exists, remove the device id from pci-stub's dynamic * ID table so that 'drivers_probe' works below. */ - if (pciDriverFile(&path, driver, "remove_id") < 0) { + if (virPCIDriverFile(&path, driver, "remove_id") < 0) { /* We do not remove PCI ID from pci-stub, and we cannot reprobe it */ if (dev->reprobe) { VIR_WARN("Could not remove PCI ID '%s' from %s, and the device " @@ -1118,36 +1118,36 @@ cleanup: VIR_FREE(path); if (result < 0) { - pciUnbindDeviceFromStub(dev, driver); + virPCIDeviceUnbindDeviceFromStub(dev, driver); } return result; } int -pciDettachDevice(pciDevice *dev, - pciDeviceList *activeDevs, - pciDeviceList *inactiveDevs, - const char *driver) +virPCIDeviceDettach(virPCIDevicePtr dev, + virPCIDeviceList *activeDevs, + virPCIDeviceList *inactiveDevs, + const char *driver) { - if (pciProbeStubDriver(driver) < 0) { + if (virPCIProbeStubDriver(driver) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to load PCI stub module %s"), driver); return -1; } - if (activeDevs && pciDeviceListFind(activeDevs, dev)) { + if (activeDevs && virPCIDeviceListFind(activeDevs, dev)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Not detaching active device %s"), dev->name); return -1; } - if (pciBindDeviceToStub(dev, driver) < 0) + if (virPCIDeviceBindDeviceToStub(dev, driver) < 0) return -1; /* Add the dev into list inactiveDevs */ - if (inactiveDevs && !pciDeviceListFind(inactiveDevs, dev)) { - if (pciDeviceListAdd(inactiveDevs, dev) < 0) + if (inactiveDevs && !virPCIDeviceListFind(inactiveDevs, dev)) { + if (virPCIDeviceListAdd(inactiveDevs, dev) < 0) return -1; } @@ -1155,29 +1155,29 @@ pciDettachDevice(pciDevice *dev, } int -pciReAttachDevice(pciDevice *dev, - pciDeviceList *activeDevs, - pciDeviceList *inactiveDevs, - const char *driver) +virPCIDeviceReAttach(virPCIDevicePtr dev, + virPCIDeviceListPtr activeDevs, + virPCIDeviceListPtr inactiveDevs, + const char *driver) { - if (pciProbeStubDriver(driver) < 0) { + if (virPCIProbeStubDriver(driver) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to load PCI stub module %s"), driver); return -1; } - if (activeDevs && pciDeviceListFind(activeDevs, dev)) { + if (activeDevs && virPCIDeviceListFind(activeDevs, dev)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Not reattaching active device %s"), dev->name); return -1; } - if (pciUnbindDeviceFromStub(dev, driver) < 0) + if (virPCIDeviceUnbindDeviceFromStub(dev, driver) < 0) return -1; /* Steal the dev from list inactiveDevs */ if (inactiveDevs) - pciDeviceListSteal(inactiveDevs, dev); + virPCIDeviceListSteal(inactiveDevs, dev); return 0; } @@ -1212,7 +1212,7 @@ pciReAttachDevice(pciDevice *dev, * holding onto the resource. */ int -pciWaitForDeviceCleanup(pciDevice *dev, const char *matcher) +virPCIDeviceWaitForCleanup(virPCIDevicePtr dev, const char *matcher) { FILE *fp; char line[160]; @@ -1292,12 +1292,12 @@ pciWaitForDeviceCleanup(pciDevice *dev, const char *matcher) } static char * -pciReadDeviceID(pciDevice *dev, const char *id_name) +virPCIDeviceReadDeviceID(virPCIDevicePtr dev, const char *id_name) { char *path = NULL; char *id_str; - if (pciDeviceFile(&path, dev->name, id_name) < 0) { + if (virPCIFile(&path, dev->name, id_name) < 0) { return NULL; } @@ -1322,16 +1322,16 @@ pciReadDeviceID(pciDevice *dev, const char *id_name) } int -pciGetDeviceAddrString(unsigned domain, - unsigned bus, - unsigned slot, - unsigned function, - char **pciConfigAddr) +virPCIGetAddrString(unsigned domain, + unsigned bus, + unsigned slot, + unsigned function, + char **pciConfigAddr) { - pciDevice *dev = NULL; + virPCIDevicePtr dev = NULL; int ret = -1; - dev = pciGetDevice(domain, bus, slot, function); + dev = virPCIDeviceNew(domain, bus, slot, function); if (dev != NULL) { if ((*pciConfigAddr = strdup(dev->name)) == NULL) { virReportOOMError(); @@ -1341,17 +1341,17 @@ pciGetDeviceAddrString(unsigned domain, } cleanup: - pciFreeDevice(dev); + virPCIDeviceFree(dev); return ret; } -pciDevice * -pciGetDevice(unsigned domain, - unsigned bus, - unsigned slot, - unsigned function) +virPCIDevicePtr +virPCIDeviceNew(unsigned domain, + unsigned bus, + unsigned slot, + unsigned function) { - pciDevice *dev; + virPCIDevicePtr dev; char *vendor = NULL; char *product = NULL; @@ -1386,8 +1386,8 @@ pciGetDevice(unsigned domain, goto error; } - vendor = pciReadDeviceID(dev, "vendor"); - product = pciReadDeviceID(dev, "device"); + vendor = virPCIDeviceReadDeviceID(dev, "vendor"); + product = virPCIDeviceReadDeviceID(dev, "device"); if (!vendor || !product) { virReportError(VIR_ERR_INTERNAL_ERROR, @@ -1413,13 +1413,13 @@ cleanup: return dev; error: - pciFreeDevice(dev); + virPCIDeviceFree(dev); dev = NULL; goto cleanup; } void -pciFreeDevice(pciDevice *dev) +virPCIDeviceFree(virPCIDevicePtr dev) { if (!dev) return; @@ -1429,70 +1429,70 @@ pciFreeDevice(pciDevice *dev) } const char * -pciDeviceGetName(pciDevice *dev) +virPCIDeviceGetName(virPCIDevicePtr dev) { return dev->name; } -void pciDeviceSetManaged(pciDevice *dev, unsigned managed) +void virPCIDeviceSetManaged(virPCIDevicePtr dev, unsigned managed) { dev->managed = !!managed; } -unsigned pciDeviceGetManaged(pciDevice *dev) +unsigned virPCIDeviceGetManaged(virPCIDevicePtr dev) { return dev->managed; } unsigned -pciDeviceGetUnbindFromStub(pciDevice *dev) +virPCIDeviceGetUnbindFromStub(virPCIDevicePtr dev) { return dev->unbind_from_stub; } void -pciDeviceSetUnbindFromStub(pciDevice *dev, unsigned unbind) +virPCIDeviceSetUnbindFromStub(virPCIDevicePtr dev, unsigned unbind) { dev->unbind_from_stub = !!unbind; } unsigned -pciDeviceGetRemoveSlot(pciDevice *dev) +virPCIDeviceGetRemoveSlot(virPCIDevicePtr dev) { return dev->remove_slot; } void -pciDeviceSetRemoveSlot(pciDevice *dev, unsigned remove_slot) +virPCIDeviceSetRemoveSlot(virPCIDevicePtr dev, unsigned remove_slot) { dev->remove_slot = !!remove_slot; } unsigned -pciDeviceGetReprobe(pciDevice *dev) +virPCIDeviceGetReprobe(virPCIDevicePtr dev) { return dev->reprobe; } void -pciDeviceSetReprobe(pciDevice *dev, unsigned reprobe) +virPCIDeviceSetReprobe(virPCIDevicePtr dev, unsigned reprobe) { dev->reprobe = !!reprobe; } void -pciDeviceSetUsedBy(pciDevice *dev, const char *name) +virPCIDeviceSetUsedBy(virPCIDevicePtr dev, const char *name) { dev->used_by = name; } const char * -pciDeviceGetUsedBy(pciDevice *dev) +virPCIDeviceGetUsedBy(virPCIDevicePtr dev) { return dev->used_by; } -void pciDeviceReAttachInit(pciDevice *pci) +void virPCIDeviceReAttachInit(virPCIDevicePtr pci) { pci->unbind_from_stub = 1; pci->remove_slot = 1; @@ -1500,10 +1500,10 @@ void pciDeviceReAttachInit(pciDevice *pci) } -pciDeviceList * -pciDeviceListNew(void) +virPCIDeviceListPtr +virPCIDeviceListNew(void) { - pciDeviceList *list; + virPCIDeviceListPtr list; if (VIR_ALLOC(list) < 0) { virReportOOMError(); @@ -1514,7 +1514,7 @@ pciDeviceListNew(void) } void -pciDeviceListFree(pciDeviceList *list) +virPCIDeviceListFree(virPCIDeviceListPtr list) { int i; @@ -1522,7 +1522,7 @@ pciDeviceListFree(pciDeviceList *list) return; for (i = 0; i < list->count; i++) { - pciFreeDevice(list->devs[i]); + virPCIDeviceFree(list->devs[i]); list->devs[i] = NULL; } @@ -1532,10 +1532,10 @@ pciDeviceListFree(pciDeviceList *list) } int -pciDeviceListAdd(pciDeviceList *list, - pciDevice *dev) +virPCIDeviceListAdd(virPCIDeviceListPtr list, + virPCIDevicePtr dev) { - if (pciDeviceListFind(list, dev)) { + if (virPCIDeviceListFind(list, dev)) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Device %s is already in use"), dev->name); return -1; @@ -1551,9 +1551,9 @@ pciDeviceListAdd(pciDeviceList *list, return 0; } -pciDevice * -pciDeviceListGet(pciDeviceList *list, - int idx) +virPCIDevicePtr +virPCIDeviceListGet(virPCIDeviceListPtr list, + int idx) { if (idx >= list->count) return NULL; @@ -1564,16 +1564,16 @@ pciDeviceListGet(pciDeviceList *list, } int -pciDeviceListCount(pciDeviceList *list) +virPCIDeviceListCount(virPCIDeviceListPtr list) { return list->count; } -pciDevice * -pciDeviceListStealIndex(pciDeviceList *list, - int idx) +virPCIDevicePtr +virPCIDeviceListStealIndex(virPCIDeviceListPtr list, + int idx) { - pciDevice *ret; + virPCIDevicePtr ret; if (idx < 0 || idx >= list->count) return NULL; @@ -1593,24 +1593,24 @@ pciDeviceListStealIndex(pciDeviceList *list, return ret; } -pciDevice * -pciDeviceListSteal(pciDeviceList *list, - pciDevice *dev) +virPCIDevicePtr +virPCIDeviceListSteal(virPCIDeviceListPtr list, + virPCIDevicePtr dev) { - return pciDeviceListStealIndex(list, pciDeviceListFindIndex(list, dev)); + return virPCIDeviceListStealIndex(list, virPCIDeviceListFindIndex(list, dev)); } void -pciDeviceListDel(pciDeviceList *list, - pciDevice *dev) +virPCIDeviceListDel(virPCIDeviceListPtr list, + virPCIDevicePtr dev) { - pciDevice *ret = pciDeviceListSteal(list, dev); + virPCIDevicePtr ret = virPCIDeviceListSteal(list, dev); if (ret) - pciFreeDevice(ret); + virPCIDeviceFree(ret); } int -pciDeviceListFindIndex(pciDeviceList *list, pciDevice *dev) +virPCIDeviceListFindIndex(virPCIDeviceListPtr list, virPCIDevicePtr dev) { int i; @@ -1623,21 +1623,21 @@ pciDeviceListFindIndex(pciDeviceList *list, pciDevice *dev) return -1; } -pciDevice * -pciDeviceListFind(pciDeviceList *list, pciDevice *dev) +virPCIDevicePtr +virPCIDeviceListFind(virPCIDeviceListPtr list, virPCIDevicePtr dev) { int i; - if ((i = pciDeviceListFindIndex(list, dev)) >= 0) + if ((i = virPCIDeviceListFindIndex(list, dev)) >= 0) return list->devs[i]; else return NULL; } -int pciDeviceFileIterate(pciDevice *dev, - pciDeviceFileActor actor, - void *opaque) +int virPCIDeviceFileIterate(virPCIDevicePtr dev, + virPCIDeviceFileActor actor, + void *opaque) { char *pcidir = NULL; char *file = NULL; @@ -1688,7 +1688,7 @@ cleanup: } static int -pciDeviceDownstreamLacksACS(pciDevice *dev) +virPCIDeviceDownstreamLacksACS(virPCIDevicePtr dev) { uint16_t flags; uint16_t ctrl; @@ -1696,30 +1696,30 @@ pciDeviceDownstreamLacksACS(pciDevice *dev) int fd; int ret = 0; - if ((fd = pciConfigOpen(dev, true)) < 0) + if ((fd = virPCIDeviceConfigOpen(dev, true)) < 0) return -1; - if (pciInitDevice(dev, fd) < 0) { + if (virPCIDeviceInitDevice(dev, fd) < 0) { ret = -1; goto cleanup; } pos = dev->pcie_cap_pos; - if (!pos || pciRead16(dev, fd, PCI_CLASS_DEVICE) != PCI_CLASS_BRIDGE_PCI) + if (!pos || virPCIDeviceRead16(dev, fd, PCI_CLASS_DEVICE) != PCI_CLASS_BRIDGE_PCI) goto cleanup; - flags = pciRead16(dev, fd, pos + PCI_EXP_FLAGS); + flags = virPCIDeviceRead16(dev, fd, pos + PCI_EXP_FLAGS); if (((flags & PCI_EXP_FLAGS_TYPE) >> 4) != PCI_EXP_TYPE_DOWNSTREAM) goto cleanup; - pos = pciFindExtendedCapabilityOffset(dev, fd, PCI_EXT_CAP_ID_ACS); + pos = virPCIDeviceFindExtendedCapabilityOffset(dev, fd, PCI_EXT_CAP_ID_ACS); if (!pos) { VIR_DEBUG("%s %s: downstream port lacks ACS", dev->id, dev->name); ret = 1; goto cleanup; } - ctrl = pciRead16(dev, fd, pos + PCI_EXT_ACS_CTRL); + ctrl = virPCIDeviceRead16(dev, fd, pos + PCI_EXT_ACS_CTRL); if ((ctrl & PCI_EXT_CAP_ACS_ENABLED) != PCI_EXT_CAP_ACS_ENABLED) { VIR_DEBUG("%s %s: downstream port has ACS disabled", dev->id, dev->name); @@ -1728,16 +1728,16 @@ pciDeviceDownstreamLacksACS(pciDevice *dev) } cleanup: - pciConfigClose(dev, fd); + virPCIDeviceConfigClose(dev, fd); return ret; } static int -pciDeviceIsBehindSwitchLackingACS(pciDevice *dev) +virPCIDeviceIsBehindSwitchLackingACS(virPCIDevicePtr dev) { - pciDevice *parent; + virPCIDevicePtr parent; - if (pciGetParentDevice(dev, &parent) < 0) + if (virPCIDeviceGetParentDevice(dev, &parent) < 0) return -1; if (!parent) { /* if we have no parent, and this is the root bus, ACS doesn't come @@ -1759,14 +1759,14 @@ pciDeviceIsBehindSwitchLackingACS(pciDevice *dev) * parent can be found */ do { - pciDevice *tmp; + virPCIDevicePtr tmp; int acs; int ret; - acs = pciDeviceDownstreamLacksACS(parent); + acs = virPCIDeviceDownstreamLacksACS(parent); if (acs) { - pciFreeDevice(parent); + virPCIDeviceFree(parent); if (acs < 0) return -1; else @@ -1774,8 +1774,8 @@ pciDeviceIsBehindSwitchLackingACS(pciDevice *dev) } tmp = parent; - ret = pciGetParentDevice(parent, &parent); - pciFreeDevice(tmp); + ret = virPCIDeviceGetParentDevice(parent, &parent); + virPCIDeviceFree(tmp); if (ret < 0) return -1; } while (parent); @@ -1783,8 +1783,8 @@ pciDeviceIsBehindSwitchLackingACS(pciDevice *dev) return 0; } -int pciDeviceIsAssignable(pciDevice *dev, - int strict_acs_check) +int virPCIDeviceIsAssignable(virPCIDevicePtr dev, + int strict_acs_check) { int ret; @@ -1793,7 +1793,7 @@ int pciDeviceIsAssignable(pciDevice *dev, * or bound to a stub driver. */ - ret = pciDeviceIsBehindSwitchLackingACS(dev); + ret = virPCIDeviceIsBehindSwitchLackingACS(dev); if (ret < 0) return 0; @@ -1819,8 +1819,8 @@ int pciDeviceIsAssignable(pciDevice *dev, * returns true if equal */ static bool -pciConfigAddressEqual(struct pci_config_address *bdf1, - struct pci_config_address *bdf2) +virPCIDeviceAddressIsEqual(virPCIDeviceAddressPtr bdf1, + virPCIDeviceAddressPtr bdf2) { return ((bdf1->domain == bdf2->domain) && (bdf1->bus == bdf2->bus) && @@ -1847,8 +1847,8 @@ logStrToLong_ui(char const *s, } static int -pciParsePciConfigAddress(char *address, - struct pci_config_address *bdf) +virPCIParseDeviceAddress(char *address, + virPCIDeviceAddressPtr bdf) { char *p = NULL; int ret = -1; @@ -1880,8 +1880,8 @@ out: } static int -pciGetPciConfigAddressFromSysfsDeviceLink(const char *device_link, - struct pci_config_address **bdf) +virPCIGetDeviceAddressFromSysfsDeviceLink(const char *device_link, + virPCIDeviceAddressPtr *bdf) { char *config_address = NULL; char *device_path = NULL; @@ -1911,7 +1911,7 @@ pciGetPciConfigAddressFromSysfsDeviceLink(const char *device_link, goto out; } - if (pciParsePciConfigAddress(config_address, *bdf) != 0) { + if (virPCIParseDeviceAddress(config_address, *bdf) != 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to parse PCI config address '%s'"), config_address); @@ -1919,7 +1919,7 @@ pciGetPciConfigAddressFromSysfsDeviceLink(const char *device_link, goto out; } - VIR_DEBUG("pci_config_address %.4x:%.2x:%.2x.%.1x", + VIR_DEBUG("virPCIDeviceAddress %.4x:%.2x:%.2x.%.1x", (*bdf)->domain, (*bdf)->bus, (*bdf)->slot, @@ -1937,8 +1937,8 @@ out: * Returns Physical function given a virtual function */ int -pciGetPhysicalFunction(const char *vf_sysfs_path, - struct pci_config_address **physical_function) +virPCIGetPhysicalFunction(const char *vf_sysfs_path, + virPCIDeviceAddressPtr *physical_function) { int ret = -1; char *device_link = NULL; @@ -1950,7 +1950,7 @@ pciGetPhysicalFunction(const char *vf_sysfs_path, virReportOOMError(); return ret; } else { - ret = pciGetPciConfigAddressFromSysfsDeviceLink(device_link, + ret = virPCIGetDeviceAddressFromSysfsDeviceLink(device_link, physical_function); } @@ -1963,9 +1963,9 @@ pciGetPhysicalFunction(const char *vf_sysfs_path, * Returns virtual functions of a physical function */ int -pciGetVirtualFunctions(const char *sysfs_path, - struct pci_config_address ***virtual_functions, - unsigned int *num_virtual_functions) +virPCIGetVirtualFunctions(const char *sysfs_path, + virPCIDeviceAddressPtr **virtual_functions, + unsigned int *num_virtual_functions) { int ret = -1; DIR *dir = NULL; @@ -1998,20 +1998,20 @@ pciGetVirtualFunctions(const char *sysfs_path, VIR_DEBUG("Number of virtual functions: %d", *num_virtual_functions); if (VIR_REALLOC_N(*virtual_functions, - (*num_virtual_functions) + 1) != 0) { + (*num_virtual_functions) + 1) != 0) { virReportOOMError(); VIR_FREE(device_link); goto out; } - if (pciGetPciConfigAddressFromSysfsDeviceLink(device_link, - &((*virtual_functions)[*num_virtual_functions])) != + if (virPCIGetDeviceAddressFromSysfsDeviceLink(device_link, + &((*virtual_functions)[*num_virtual_functions])) != SRIOV_FOUND) { /* We should not get back SRIOV_NOT_FOUND in this * case, so if we do, it's an error. */ virReportError(VIR_ERR_INTERNAL_ERROR, _("Failed to get SR IOV function from device " - "link '%s'"), device_link); + "link '%s'"), device_link); VIR_FREE(device_link); goto out; } else { @@ -2034,13 +2034,13 @@ out: * Returns 1 if vf device is a virtual function, 0 if not, -1 on error */ int -pciDeviceIsVirtualFunction(const char *vf_sysfs_device_link) +virPCIIsVirtualFunction(const char *vf_sysfs_device_link) { char *vf_sysfs_physfn_link = NULL; int ret = -1; if (virAsprintf(&vf_sysfs_physfn_link, "%s/physfn", - vf_sysfs_device_link) < 0) { + vf_sysfs_device_link) < 0) { virReportOOMError(); return ret; } @@ -2056,40 +2056,40 @@ pciDeviceIsVirtualFunction(const char *vf_sysfs_device_link) * Returns the sriov virtual function index of vf given its pf */ int -pciGetVirtualFunctionIndex(const char *pf_sysfs_device_link, - const char *vf_sysfs_device_link, - int *vf_index) +virPCIGetVirtualFunctionIndex(const char *pf_sysfs_device_link, + const char *vf_sysfs_device_link, + int *vf_index) { int ret = -1, i; unsigned int num_virt_fns = 0; - struct pci_config_address *vf_bdf = NULL; - struct pci_config_address **virt_fns = NULL; + virPCIDeviceAddressPtr vf_bdf = NULL; + virPCIDeviceAddressPtr *virt_fns = NULL; - if (pciGetPciConfigAddressFromSysfsDeviceLink(vf_sysfs_device_link, - &vf_bdf) < 0) + if (virPCIGetDeviceAddressFromSysfsDeviceLink(vf_sysfs_device_link, + &vf_bdf) < 0) return ret; - if (pciGetVirtualFunctions(pf_sysfs_device_link, &virt_fns, - &num_virt_fns) < 0) { + if (virPCIGetVirtualFunctions(pf_sysfs_device_link, &virt_fns, + &num_virt_fns) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Error getting physical function's '%s' " - "virtual_functions"), pf_sysfs_device_link); + "virtual_functions"), pf_sysfs_device_link); goto out; } for (i = 0; i < num_virt_fns; i++) { - if (pciConfigAddressEqual(vf_bdf, virt_fns[i])) { - *vf_index = i; - ret = 0; - break; - } + if (virPCIDeviceAddressIsEqual(vf_bdf, virt_fns[i])) { + *vf_index = i; + ret = 0; + break; + } } out: /* free virtual functions */ for (i = 0; i < num_virt_fns; i++) - VIR_FREE(virt_fns[i]); + VIR_FREE(virt_fns[i]); VIR_FREE(virt_fns); VIR_FREE(vf_bdf); @@ -2102,10 +2102,10 @@ out: */ int -pciSysfsFile(char *pciDeviceName, char **pci_sysfs_device_link) +virPCIGetSysfsFile(char *virPCIDeviceName, char **pci_sysfs_device_link) { if (virAsprintf(pci_sysfs_device_link, PCI_SYSFS "devices/%s", - pciDeviceName) < 0) { + virPCIDeviceName) < 0) { virReportOOMError(); return -1; } @@ -2114,8 +2114,8 @@ pciSysfsFile(char *pciDeviceName, char **pci_sysfs_device_link) } int -pciConfigAddressToSysfsFile(struct pci_config_address *dev, - char **pci_sysfs_device_link) +virPCIDeviceAddressGetSysfsFile(virPCIDeviceAddressPtr dev, + char **pci_sysfs_device_link) { if (virAsprintf(pci_sysfs_device_link, PCI_SYSFS "devices/%04x:%02x:%02x.%x", dev->domain, @@ -2131,68 +2131,68 @@ pciConfigAddressToSysfsFile(struct pci_config_address *dev, * Returns the network device name of a pci device */ int -pciDeviceNetName(char *device_link_sysfs_path, char **netname) -{ - char *pcidev_sysfs_net_path = NULL; - int ret = -1; - DIR *dir = NULL; - struct dirent *entry = NULL; - - if (virBuildPath(&pcidev_sysfs_net_path, device_link_sysfs_path, - "net") == -1) { - virReportOOMError(); - return -1; - } - - dir = opendir(pcidev_sysfs_net_path); - if (dir == NULL) - goto out; - - while ((entry = readdir(dir))) { - if (STREQ(entry->d_name, ".") || - STREQ(entry->d_name, "..")) - continue; +virPCIGetNetName(char *device_link_sysfs_path, char **netname) +{ + char *pcidev_sysfs_net_path = NULL; + int ret = -1; + DIR *dir = NULL; + struct dirent *entry = NULL; - /* Assume a single directory entry */ - *netname = strdup(entry->d_name); - if (!*netname) - virReportOOMError(); - else - ret = 0; - break; - } + if (virBuildPath(&pcidev_sysfs_net_path, device_link_sysfs_path, + "net") == -1) { + virReportOOMError(); + return -1; + } + + dir = opendir(pcidev_sysfs_net_path); + if (dir == NULL) + goto out; - closedir(dir); + while ((entry = readdir(dir))) { + if (STREQ(entry->d_name, ".") || + STREQ(entry->d_name, "..")) + continue; + + /* Assume a single directory entry */ + *netname = strdup(entry->d_name); + if (!*netname) + virReportOOMError(); + else + ret = 0; + break; + } + + closedir(dir); out: - VIR_FREE(pcidev_sysfs_net_path); + VIR_FREE(pcidev_sysfs_net_path); - return ret; + return ret; } int -pciDeviceGetVirtualFunctionInfo(const char *vf_sysfs_device_path, - char **pfname, int *vf_index) +virPCIGetVirtualFunctionInfo(const char *vf_sysfs_device_path, + char **pfname, int *vf_index) { - struct pci_config_address *pf_config_address = NULL; + virPCIDeviceAddressPtr pf_config_address = NULL; char *pf_sysfs_device_path = NULL; int ret = -1; - if (pciGetPhysicalFunction(vf_sysfs_device_path, &pf_config_address) < 0) + if (virPCIGetPhysicalFunction(vf_sysfs_device_path, &pf_config_address) < 0) return ret; - if (pciConfigAddressToSysfsFile(pf_config_address, - &pf_sysfs_device_path) < 0) { + if (virPCIDeviceAddressGetSysfsFile(pf_config_address, + &pf_sysfs_device_path) < 0) { VIR_FREE(pf_config_address); return ret; } - if (pciGetVirtualFunctionIndex(pf_sysfs_device_path, vf_sysfs_device_path, - vf_index) < 0) + if (virPCIGetVirtualFunctionIndex(pf_sysfs_device_path, vf_sysfs_device_path, + vf_index) < 0) goto cleanup; - ret = pciDeviceNetName(pf_sysfs_device_path, pfname); + ret = virPCIGetNetName(pf_sysfs_device_path, pfname); cleanup: VIR_FREE(pf_config_address); @@ -2205,33 +2205,33 @@ cleanup: static const char *unsupported = N_("not supported on non-linux platforms"); int -pciGetPhysicalFunction(const char *vf_sysfs_path ATTRIBUTE_UNUSED, - struct pci_config_address **physical_function ATTRIBUTE_UNUSED) +virPCIGetPhysicalFunction(const char *vf_sysfs_path ATTRIBUTE_UNUSED, + virPCIDeviceAddressPtr *physical_function ATTRIBUTE_UNUSED) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported)); return -1; } int -pciGetVirtualFunctions(const char *sysfs_path ATTRIBUTE_UNUSED, - struct pci_config_address ***virtual_functions ATTRIBUTE_UNUSED, - unsigned int *num_virtual_functions ATTRIBUTE_UNUSED) +virPCIGetVirtualFunctions(const char *sysfs_path ATTRIBUTE_UNUSED, + virPCIDeviceAddressPtr **virtual_functions ATTRIBUTE_UNUSED, + unsigned int *num_virtual_functions ATTRIBUTE_UNUSED) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported)); return -1; } int -pciDeviceIsVirtualFunction(const char *vf_sysfs_device_link ATTRIBUTE_UNUSED) +virPCIDeviceIsVirtualFunction(const char *vf_sysfs_device_link ATTRIBUTE_UNUSED) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported)); return -1; } int -pciGetVirtualFunctionIndex(const char *pf_sysfs_device_link ATTRIBUTE_UNUSED, - const char *vf_sysfs_device_link ATTRIBUTE_UNUSED, - int *vf_index ATTRIBUTE_UNUSED) +virPCIGetVirtualFunctionIndex(const char *pf_sysfs_device_link ATTRIBUTE_UNUSED, + const char *vf_sysfs_device_link ATTRIBUTE_UNUSED, + int *vf_index ATTRIBUTE_UNUSED) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported)); return -1; @@ -2239,15 +2239,15 @@ pciGetVirtualFunctionIndex(const char *pf_sysfs_device_link ATTRIBUTE_UNUSED, } int -pciConfigAddressToSysfsFile(struct pci_config_address *dev ATTRIBUTE_UNUSED, - char **pci_sysfs_device_link ATTRIBUTE_UNUSED) +virPCIDeviceAddressGetSysfsFile(virPCIDeviceAddressPtr dev ATTRIBUTE_UNUSED, + char **pci_sysfs_device_link ATTRIBUTE_UNUSED) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported)); return -1; } int -pciDeviceNetName(char *device_link_sysfs_path ATTRIBUTE_UNUSED, +virPCIGetNetName(char *device_link_sysfs_path ATTRIBUTE_UNUSED, char **netname ATTRIBUTE_UNUSED) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported)); @@ -2255,9 +2255,9 @@ pciDeviceNetName(char *device_link_sysfs_path ATTRIBUTE_UNUSED, } int -pciDeviceGetVirtualFunctionInfo(const char *vf_sysfs_device_path ATTRIBUTE_UNUSED, - char **pfname ATTRIBUTE_UNUSED, - int *vf_index ATTRIBUTE_UNUSED) +virPCIGetVirtualFunctionInfo(const char *vf_sysfs_device_path ATTRIBUTE_UNUSED, + char **pfname ATTRIBUTE_UNUSED, + int *vf_index ATTRIBUTE_UNUSED) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _(unsupported)); return -1; diff --git a/src/util/virpci.h b/src/util/virpci.h index bf7da01..3ca7545 100644 --- a/src/util/virpci.h +++ b/src/util/virpci.h @@ -26,67 +26,74 @@ # include "internal.h" -typedef struct _pciDevice pciDevice; -typedef struct _pciDeviceList pciDeviceList; - -struct pci_config_address { +typedef struct _virPCIDevice virPCIDevice; +typedef virPCIDevice *virPCIDevicePtr; +typedef struct _virPCIDeviceAddress virPCIDeviceAddress; +typedef virPCIDeviceAddress *virPCIDeviceAddressPtr; +typedef struct _virPCIDeviceList virPCIDeviceList; +typedef virPCIDeviceList *virPCIDeviceListPtr; + +struct _virPCIDeviceAddress { unsigned int domain; unsigned int bus; unsigned int slot; unsigned int function; }; -pciDevice *pciGetDevice (unsigned domain, - unsigned bus, - unsigned slot, - unsigned function); -void pciFreeDevice (pciDevice *dev); -const char *pciDeviceGetName (pciDevice *dev); -int pciDettachDevice (pciDevice *dev, - pciDeviceList *activeDevs, - pciDeviceList *inactiveDevs, - const char *driver); -int pciReAttachDevice (pciDevice *dev, - pciDeviceList *activeDevs, - pciDeviceList *inactiveDevs, - const char *driver); -int pciResetDevice (pciDevice *dev, - pciDeviceList *activeDevs, - pciDeviceList *inactiveDevs); -void pciDeviceSetManaged(pciDevice *dev, - unsigned managed); -unsigned pciDeviceGetManaged(pciDevice *dev); -void pciDeviceSetUsedBy(pciDevice *dev, - const char *used_by); -const char *pciDeviceGetUsedBy(pciDevice *dev); -unsigned pciDeviceGetUnbindFromStub(pciDevice *dev); -void pciDeviceSetUnbindFromStub(pciDevice *dev, - unsigned unbind); -unsigned pciDeviceGetRemoveSlot(pciDevice *dev); -void pciDeviceSetRemoveSlot(pciDevice *dev, - unsigned remove_slot); -unsigned pciDeviceGetReprobe(pciDevice *dev); -void pciDeviceSetReprobe(pciDevice *dev, - unsigned reprobe); -void pciDeviceReAttachInit(pciDevice *dev); - -pciDeviceList *pciDeviceListNew (void); -void pciDeviceListFree (pciDeviceList *list); -int pciDeviceListAdd (pciDeviceList *list, - pciDevice *dev); -pciDevice * pciDeviceListGet (pciDeviceList *list, - int idx); -int pciDeviceListCount (pciDeviceList *list); -pciDevice * pciDeviceListSteal (pciDeviceList *list, - pciDevice *dev); -pciDevice * pciDeviceListStealIndex(pciDeviceList *list, - int idx); -void pciDeviceListDel (pciDeviceList *list, - pciDevice *dev); -pciDevice * pciDeviceListFind (pciDeviceList *list, - pciDevice *dev); -int pciDeviceListFindIndex(pciDeviceList *list, - pciDevice *dev); +virPCIDevicePtr virPCIDeviceNew(unsigned domain, + unsigned bus, + unsigned slot, + unsigned function); +void virPCIDeviceFree(virPCIDevicePtr dev); +const char *virPCIDeviceGetName(virPCIDevicePtr dev); + +int virPCIDeviceDettach(virPCIDevicePtr dev, + virPCIDeviceListPtr activeDevs, + virPCIDeviceListPtr inactiveDevs, + const char *driver); +int virPCIDeviceReAttach(virPCIDevicePtr dev, + virPCIDeviceListPtr activeDevs, + virPCIDeviceListPtr inactiveDevs, + const char *driver); +int virPCIDeviceReset(virPCIDevicePtr dev, + virPCIDeviceListPtr activeDevs, + virPCIDeviceListPtr inactiveDevs); + +void virPCIDeviceSetManaged(virPCIDevice *dev, + unsigned managed); +unsigned virPCIDeviceGetManaged(virPCIDevice *dev); +void virPCIDeviceSetUsedBy(virPCIDevice *dev, + const char *used_by); +const char *virPCIDeviceGetUsedBy(virPCIDevice *dev); +unsigned virPCIDeviceGetUnbindFromStub(virPCIDevicePtr dev); +void virPCIDeviceSetUnbindFromStub(virPCIDevice *dev, + unsigned unbind); +unsigned virPCIDeviceGetRemoveSlot(virPCIDevicePtr dev); +void virPCIDeviceSetRemoveSlot(virPCIDevice *dev, + unsigned remove_slot); +unsigned virPCIDeviceGetReprobe(virPCIDevicePtr dev); +void virPCIDeviceSetReprobe(virPCIDevice *dev, + unsigned reprobe); +void virPCIDeviceReAttachInit(virPCIDevice *dev); + + +virPCIDeviceListPtr virPCIDeviceListNew(void); +void virPCIDeviceListFree(virPCIDeviceListPtr list); +int virPCIDeviceListAdd(virPCIDeviceListPtr list, + virPCIDevicePtr dev); +virPCIDevicePtr virPCIDeviceListGet(virPCIDeviceListPtr list, + int idx); +int virPCIDeviceListCount(virPCIDeviceListPtr list); +virPCIDevicePtr virPCIDeviceListSteal(virPCIDeviceListPtr list, + virPCIDevicePtr dev); +virPCIDevicePtr virPCIDeviceListStealIndex(virPCIDeviceListPtr list, + int idx); +void virPCIDeviceListDel(virPCIDeviceListPtr list, + virPCIDevicePtr dev); +virPCIDevicePtr virPCIDeviceListFind(virPCIDeviceListPtr list, + virPCIDevicePtr dev); +int virPCIDeviceListFindIndex(virPCIDeviceListPtr list, + virPCIDevicePtr dev); /* * Callback that will be invoked once for each file @@ -95,46 +102,47 @@ int pciDeviceListFindIndex(pciDeviceList *list, * Should return 0 if successfully processed, or * -1 to indicate error and abort iteration */ -typedef int (*pciDeviceFileActor)(pciDevice *dev, - const char *path, void *opaque); +typedef int (*virPCIDeviceFileActor)(virPCIDevicePtr dev, + const char *path, void *opaque); -int pciDeviceFileIterate(pciDevice *dev, - pciDeviceFileActor actor, - void *opaque); +int virPCIDeviceFileIterate(virPCIDevicePtr dev, + virPCIDeviceFileActor actor, + void *opaque); -int pciDeviceIsAssignable(pciDevice *dev, - int strict_acs_check); -int pciWaitForDeviceCleanup(pciDevice *dev, const char *matcher); +int virPCIDeviceIsAssignable(virPCIDevicePtr dev, + int strict_acs_check); +int virPCIDeviceWaitForCleanup(virPCIDevicePtr dev, const char *matcher); -int pciGetPhysicalFunction(const char *sysfs_path, - struct pci_config_address **phys_fn); +int virPCIGetPhysicalFunction(const char *sysfs_path, + virPCIDeviceAddressPtr *phys_fn); -int pciGetVirtualFunctions(const char *sysfs_path, - struct pci_config_address ***virtual_functions, - unsigned int *num_virtual_functions); +int virPCIGetVirtualFunctions(const char *sysfs_path, + virPCIDeviceAddressPtr **virtual_functions, + unsigned int *num_virtual_functions); -int pciDeviceIsVirtualFunction(const char *vf_sysfs_device_link); +int virPCIIsVirtualFunction(const char *vf_sysfs_device_link); -int pciGetVirtualFunctionIndex(const char *pf_sysfs_device_link, - const char *vf_sysfs_device_link, - int *vf_index); +int virPCIGetVirtualFunctionIndex(const char *pf_sysfs_device_link, + const char *vf_sysfs_device_link, + int *vf_index); -int pciConfigAddressToSysfsFile(struct pci_config_address *dev, - char **pci_sysfs_device_link); +int virPCIDeviceAddressGetSysfsFile(virPCIDeviceAddressPtr dev, + char **pci_sysfs_device_link); -int pciDeviceNetName(char *device_link_sysfs_path, char **netname); +int virPCIGetNetName(char *device_link_sysfs_path, char **netname); -int pciSysfsFile(char *pciDeviceName, char **pci_sysfs_device_link) +int virPCIGetSysfsFile(char *virPCIDeviceName, + char **pci_sysfs_device_link) ATTRIBUTE_RETURN_CHECK; -int pciGetDeviceAddrString(unsigned domain, - unsigned bus, - unsigned slot, - unsigned function, - char **pciConfigAddr) +int virPCIGetAddrString(unsigned domain, + unsigned bus, + unsigned slot, + unsigned function, + char **pciConfigAddr) ATTRIBUTE_NONNULL(5) ATTRIBUTE_RETURN_CHECK; -int pciDeviceGetVirtualFunctionInfo(const char *vf_sysfs_device_path, - char **pfname, int *vf_index); +int virPCIGetVirtualFunctionInfo(const char *vf_sysfs_device_path, + char **pfname, int *vf_index); #endif /* __VIR_PCI_H__ */ diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c index 2795ebc..2c8b73e 100644 --- a/src/xen/xen_driver.c +++ b/src/xen/xen_driver.c @@ -2102,23 +2102,23 @@ out: static int xenUnifiedNodeDeviceDettach(virNodeDevicePtr dev) { - pciDevice *pci; + virPCIDevicePtr pci; unsigned domain, bus, slot, function; int ret = -1; if (xenUnifiedNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0) return -1; - pci = pciGetDevice(domain, bus, slot, function); + pci = virPCIDeviceNew(domain, bus, slot, function); if (!pci) return -1; - if (pciDettachDevice(pci, NULL, NULL, "pciback") < 0) + if (virPCIDeviceDettach(pci, NULL, NULL, "pciback") < 0) goto out; ret = 0; out: - pciFreeDevice(pci); + virPCIDeviceFree(pci); return ret; } @@ -2183,7 +2183,7 @@ out: static int xenUnifiedNodeDeviceReAttach(virNodeDevicePtr dev) { - pciDevice *pci; + virPCIDevicePtr pci; unsigned domain, bus, slot, function; int ret = -1; int domid; @@ -2191,7 +2191,7 @@ xenUnifiedNodeDeviceReAttach(virNodeDevicePtr dev) if (xenUnifiedNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0) return -1; - pci = pciGetDevice(domain, bus, slot, function); + pci = virPCIDeviceNew(domain, bus, slot, function); if (!pci) return -1; @@ -2203,35 +2203,35 @@ xenUnifiedNodeDeviceReAttach(virNodeDevicePtr dev) goto out; } - if (pciReAttachDevice(pci, NULL, NULL, "pciback") < 0) + if (virPCIDeviceReAttach(pci, NULL, NULL, "pciback") < 0) goto out; ret = 0; out: - pciFreeDevice(pci); + virPCIDeviceFree(pci); return ret; } static int xenUnifiedNodeDeviceReset(virNodeDevicePtr dev) { - pciDevice *pci; + virPCIDevicePtr pci; unsigned domain, bus, slot, function; int ret = -1; if (xenUnifiedNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0) return -1; - pci = pciGetDevice(domain, bus, slot, function); + pci = virPCIDeviceNew(domain, bus, slot, function); if (!pci) return -1; - if (pciResetDevice(pci, NULL, NULL) < 0) + if (virPCIDeviceReset(pci, NULL, NULL) < 0) goto out; ret = 0; out: - pciFreeDevice(pci); + virPCIDeviceFree(pci); return ret; } -- 1.8.1