cyliu@xxxxxxxx wrote: > From: Chunyan Liu <cyliu@xxxxxxxx> > > Add hostdev passthrough common library so that it could be shared by all drivers > and maintain a global hostdev state. > > Signed-off-by: Chunyan Liu <cyliu@xxxxxxxx> > --- > po/POTFILES.in | 1 + > src/Makefile.am | 1 + > src/libvirt_private.syms | 22 + > src/util/virhostdev.c | 1683 ++++++++++++++++++++++++++++++++++++++++++++++ > src/util/virhostdev.h | 123 ++++ > src/util/virpci.c | 21 +- > src/util/virpci.h | 7 +- > src/util/virscsi.c | 22 +- > src/util/virscsi.h | 8 +- > src/util/virusb.c | 23 +- > src/util/virusb.h | 8 +- > 11 files changed, 1895 insertions(+), 24 deletions(-) > create mode 100644 src/util/virhostdev.c > create mode 100644 src/util/virhostdev.h > > diff --git a/po/POTFILES.in b/po/POTFILES.in > index 1fd84af..9176b95 100644 > --- a/po/POTFILES.in > +++ b/po/POTFILES.in > @@ -193,6 +193,7 @@ src/util/viruri.c > src/util/virusb.c > src/util/virutil.c > src/util/virxml.c > +src/util/virhostdev.c > src/vbox/vbox_MSCOMGlue.c > src/vbox/vbox_XPCOMCGlue.c > src/vbox/vbox_driver.c > diff --git a/src/Makefile.am b/src/Makefile.am > index 62e427e..a89e414 100644 > --- a/src/Makefile.am > +++ b/src/Makefile.am > @@ -145,6 +145,7 @@ UTIL_SOURCES = \ > util/virutil.c util/virutil.h \ > util/viruuid.c util/viruuid.h \ > util/virxml.c util/virxml.h \ > + util/virhostdev.c util/virhostdev.h \ > Tabs should be used here instead of spaces. Also, the '\' should be aligned with the others. > $(NULL) > > > diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms > index 201b2cb..5dba1b5 100644 > --- a/src/libvirt_private.syms > +++ b/src/libvirt_private.syms > @@ -1424,6 +1424,28 @@ virHookInitialize; > virHookPresent; > > > +#util/virhostdev.h > +virHostdevGetActivePciHostdevs; > +virHostdevGetActiveScsiHostdevs; > +virHostdevGetActiveUsbHostdevs; > +virHostdevGetDomainActivePciHostdevs; > +virHostdevGetDomainActiveScsiHostdevs; > +virHostdevGetDomainActiveUsbHostdevs; > +virHostdevManagerGetDefault; > +virHostdevNameListFree; > +virHostdevPciNodeDeviceDetach; > +virHostdevPciNodeDeviceReAttach; > +virHostdevPciNodeDeviceReset; > +virHostdevPrepareDomainHostdevs; > +virHostdevPreparePciHostdevs; > +virHostdevPrepareScsiHostdevs; > +virHostdevPrepareUsbHostdevs; > +virHostdevReAttachDomainHostdevs; > +virHostdevReAttachPciHostdevs; > +virHostdevReAttachScsiHostdevs; > +virHostdevReAttachUsbHostdevs; > + > + > # util/viridentity.h > virIdentityGetAttr; > virIdentityGetCurrent; > diff --git a/src/util/virhostdev.c b/src/util/virhostdev.c > new file mode 100644 > index 0000000..0712e89 > --- /dev/null > +++ b/src/util/virhostdev.c > @@ -0,0 +1,1683 @@ > +/* virhostdev.h: hostdev management > + * > + * Copyright (C) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. > + * Copyright (C) 2006-2007, 2009-2013 Red Hat, Inc. > + * Copyright (C) 2006 Daniel P. Berrange > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2.1 of the License, or (at your option) any later version. > + * > + * This library is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library. If not, see > + * <http://www.gnu.org/licenses/>. > + * > + * Author: Chunyan Liu <cyliu@xxxxxxxx> > + * Author: Daniel P. Berrange <berrange@xxxxxxxxxx> > + */ > + > +#include <config.h> > + > +#include "virhostdev.h" > + > +#include <sys/types.h> > +#include <sys/stat.h> > +#include <unistd.h> > +#include <stdlib.h> > +#include <stdio.h> > + > +#include "viralloc.h" > +#include "virstring.h" > +#include "virfile.h" > +#include "virerror.h" > +#include "virlog.h" > +#include "virpci.h" > +#include "virusb.h" > +#include "virscsi.h" > +#include "virnetdev.h" > +#include "virutil.h" > + > +/* For virReportOOMError() and virReportSystemError() */ > +#define VIR_FROM_THIS VIR_FROM_NONE > + > +/* Same name as in virDriver. For special check. */ > +#define LIBXL_DRIVER_NAME "xenlight" > +#define QEMU_DRIVER_NAME "QEMU" > + > +struct _virHostdevManager{ > + char *stateDir; > + > + virPCIDeviceListPtr activePciHostdevs; > + virPCIDeviceListPtr inactivePciHostdevs; > + virUSBDeviceListPtr activeUsbHostdevs; > + virSCSIDeviceListPtr activeScsiHostdevs; > +}; > + > +static virHostdevManagerPtr hostdevMgr; > + > +static int > +virHostdevOnceInit(void) > +{ > + char ebuf[1024]; > Typically a newline after local variables. > + if (VIR_ALLOC(hostdevMgr) < 0) > + goto out_of_memory; > + > + if ((hostdevMgr->activePciHostdevs = virPCIDeviceListNew()) == NULL) > + goto error; > + > + if ((hostdevMgr->activeUsbHostdevs = virUSBDeviceListNew()) == NULL) > + goto error; > + > + if ((hostdevMgr->inactivePciHostdevs = virPCIDeviceListNew()) == NULL) > + goto error; > + > + if ((hostdevMgr->activeScsiHostdevs = virSCSIDeviceListNew()) == NULL) > + goto error; > + > + if (virAsprintf(&hostdevMgr->stateDir, > + "%s",HOSTDEV_STATE_DIR) < 0) > This should all fit on one line. Also, need a space between ',' and 'HOSTDEV_STATE_DIR'. > + goto out_of_memory; > + > + if (virFileMakePath(hostdevMgr->stateDir) < 0) { > + VIR_ERROR(_("Failed to create state dir '%s': %s"), > + hostdevMgr->stateDir, virStrerror(errno, ebuf, sizeof(ebuf))); > + goto error; > + } > + > + return 0; > + > +out_of_memory: > + virReportOOMError(); > VIR_ALLOC and virAsprintf already report the error so this can be dropped. > +error: > + return -1; > +} > + > +VIR_ONCE_GLOBAL_INIT(virHostdev) > + > +virHostdevManagerPtr > +virHostdevManagerGetDefault(void) > +{ > + virHostdevInitialize(); > + return hostdevMgr; > +} > + > +static int > +virHostdevPciSysfsPath(virDomainHostdevDefPtr hostdev, char **sysfs_path) > +{ > + virPCIDeviceAddress config_address; > + > + config_address.domain = hostdev->source.subsys.u.pci.addr.domain; > + config_address.bus = hostdev->source.subsys.u.pci.addr.bus; > + config_address.slot = hostdev->source.subsys.u.pci.addr.slot; > + config_address.function = hostdev->source.subsys.u.pci.addr.function; > + > + return virPCIDeviceAddressGetSysfsFile(&config_address, sysfs_path); > +} > + > +static int > +virHostdevIsVirtualFunction(virDomainHostdevDefPtr hostdev) > +{ > + char *sysfs_path = NULL; > + int ret = -1; > + > + if (virHostdevPciSysfsPath(hostdev, &sysfs_path) < 0) > + return ret; > + > + ret = virPCIIsVirtualFunction(sysfs_path); > + > + VIR_FREE(sysfs_path); > + > + return ret; > +} > + > +static int > +virHostdevNetDevice(virDomainHostdevDefPtr hostdev, > + char **linkdev, > + int *vf) > +{ > + int ret = -1; > + char *sysfs_path = NULL; > + > + if (virHostdevPciSysfsPath(hostdev, &sysfs_path) < 0) > + return ret; > + > + if (virPCIIsVirtualFunction(sysfs_path) == 1) { > + if (virPCIGetVirtualFunctionInfo(sysfs_path, linkdev, > + vf) < 0) > Fits on one line. > + goto cleanup; > + } else { > + if (virPCIGetNetName(sysfs_path, linkdev) < 0) > + goto cleanup; > + *vf = -1; > + } > + > + ret = 0; > + > +cleanup: > + VIR_FREE(sysfs_path); > + > + return ret; > +} > + > +static int > +virHostdevNetConfigVirtPortProfile(const char *linkdev, int vf, > + virNetDevVPortProfilePtr virtPort, > + const virMacAddrPtr macaddr, > + const unsigned char *uuid, > + int associate) > +{ > + int ret = -1; > + > + if (!virtPort) > + return ret; > + > + switch (virtPort->virtPortType) { > + case VIR_NETDEV_VPORT_PROFILE_NONE: > + case VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH: > + case VIR_NETDEV_VPORT_PROFILE_8021QBG: > + case VIR_NETDEV_VPORT_PROFILE_LAST: > + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, > + _("virtualport type %s is " > + "currently not supported on interfaces of type " > + "hostdev"), > + virNetDevVPortTypeToString(virtPort->virtPortType)); > + break; > + > + case VIR_NETDEV_VPORT_PROFILE_8021QBH: > + if (associate) > + ret = virNetDevVPortProfileAssociate(NULL, virtPort, macaddr, > + linkdev, vf, uuid, > + VIR_NETDEV_VPORT_PROFILE_OP_CREATE, false); > + else > + ret = virNetDevVPortProfileDisassociate(NULL, virtPort, > + macaddr, linkdev, vf, > + VIR_NETDEV_VPORT_PROFILE_OP_DESTROY); > + break; > + } > + > + return ret; > +} > + > +static int > +virHostdevNetConfigReplace(virDomainHostdevDefPtr hostdev, > + const unsigned char *uuid, > + char *stateDir) > +{ > + char *linkdev = NULL; > + virNetDevVlanPtr vlan; > + virNetDevVPortProfilePtr virtPort; > + int ret = -1; > + int vf = -1; > + int vlanid = -1; > + int port_profile_associate = 1; > + int isvf; > + > + isvf = virHostdevIsVirtualFunction(hostdev); > + if (isvf <= 0) { > + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", > + _("Interface type hostdev is currently supported on" > + " SR-IOV Virtual Functions only")); > To be consistent, space should be after 'on' instead of before 'SR-IOV Virtual Functions only'. > + return ret; > + } > + > + if (virHostdevNetDevice(hostdev, &linkdev, &vf) < 0) > + return ret; > + > + vlan = virDomainNetGetActualVlan(hostdev->parent.data.net); > + virtPort = virDomainNetGetActualVirtPortProfile( > + hostdev->parent.data.net); > Fits on one line. > + if (virtPort) { > + if (vlan) { > + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, > + _("direct setting of the vlan tag is not allowed " > + "for hostdev devices using %s mode"), > + virNetDevVPortTypeToString(virtPort->virtPortType)); > + goto cleanup; > + } > + ret = virHostdevNetConfigVirtPortProfile(linkdev, vf, > + virtPort, &hostdev->parent.data.net->mac, uuid, > + port_profile_associate); > + } else { > + /* Set only mac and vlan */ > + if (vlan) { > + if (vlan->nTags != 1 || vlan->trunk) { > + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", > + _("vlan trunking is not supported " > + "by SR-IOV network devices")); > + goto cleanup; > + } > + if (vf == -1) { > + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, > + _("vlan can only be set for SR-IOV VFs, but " > + "%s is not a VF"), linkdev); > + goto cleanup; > + } > + vlanid = vlan->tag[0]; > + } else if (vf >= 0) { > + vlanid = 0; /* assure any current vlan tag is reset */ > + } > + > + ret = virNetDevReplaceNetConfig(linkdev, vf, > + &hostdev->parent.data.net->mac, > + vlanid, stateDir); > + } > +cleanup: > + VIR_FREE(linkdev); > + return ret; > +} > + > +static int > +virHostdevNetConfigRestore(virDomainHostdevDefPtr hostdev, > + char *stateDir) > +{ > + char *linkdev = NULL; > + virNetDevVPortProfilePtr virtPort; > + int ret = -1; > + int vf = -1; > + int port_profile_associate = 0; > + int isvf; > + > + isvf = virHostdevIsVirtualFunction(hostdev); > + if (isvf <= 0) { > + virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", > + _("Interface type hostdev is currently supported on" > + " SR-IOV Virtual Functions only")); > Same comment here about trailing vs leading space on multiple line error messages. > + return ret; > + } > + > + if (virHostdevNetDevice(hostdev, &linkdev, &vf) < 0) > + return ret; > + > + virtPort = virDomainNetGetActualVirtPortProfile( > + hostdev->parent.data.net); > Fits on one line. > + if (virtPort) > + ret = virHostdevNetConfigVirtPortProfile(linkdev, vf, virtPort, > + &hostdev->parent.data.net->mac, NULL, > + port_profile_associate); > Parameter whitespace alignment. > + else > + ret = virNetDevRestoreNetConfig(linkdev, vf, stateDir); > + > + VIR_FREE(linkdev); > + > + return ret; > +} > + > +static virPCIDeviceListPtr > +virHostdevGetPciHostDeviceList(virDomainHostdevDefPtr *hostdevs, > + int nhostdevs, > + const char *driver) > +{ > + virPCIDeviceListPtr list; > + size_t i; > + > + if (!(list = virPCIDeviceListNew())) > + return NULL; > + > + for (i = 0; i < nhostdevs; i++) { > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + virPCIDevicePtr dev; > + > + if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) > + continue; > + if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) > + continue; > + > + dev = virPCIDeviceNew(hostdev->source.subsys.u.pci.addr.domain, > + hostdev->source.subsys.u.pci.addr.bus, > + hostdev->source.subsys.u.pci.addr.slot, > + hostdev->source.subsys.u.pci.addr.function); > + if (!dev) { > + virObjectUnref(list); > + return NULL; > + } > + > + if (virPCIDeviceListAdd(list, dev) < 0) { > + virPCIDeviceFree(dev); > + virObjectUnref(list); > + return NULL; > + } > + > + virPCIDeviceSetManaged(dev, hostdev->managed); > + > + switch (hostdev->source.subsys.u.pci.backend) { > + case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO: > + if (virPCIDeviceSetStubDriver(dev, "vfio-pci") < 0) { > + virObjectUnref(list); > + return NULL; > + } > + break; > + > + case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_KVM : > + if (virPCIDeviceSetStubDriver(dev, "pci-stub") < 0) { > + virObjectUnref(list); > + return NULL; > + } > + break; > + > + case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT: > + /* driver name not specified, if it's libxl driver, > + * use pciback; otherwise, use pci-stub > + */ > + if (STREQ(driver, LIBXL_DRIVER_NAME)) { > + if (virPCIDeviceSetStubDriver(dev, "pciback") < 0) { > + virObjectUnref(list); > + return NULL; > + } > + } else { > + if (virPCIDeviceSetStubDriver(dev, "pci-stub") < 0) { > + virObjectUnref(list); > + return NULL; > + } > + } > + break; > + } > + } > + > + return list; > +} > + > +int > +virHostdevPreparePciHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + const unsigned char *uuid, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs, > + unsigned int flags) > +{ > + virPCIDeviceListPtr pcidevs; > + int last_processed_hostdev_vf = -1; > + size_t i; > + int ret = -1; > + > + virObjectLock(mgr->activePciHostdevs); > + virObjectLock(mgr->inactivePciHostdevs); > + > + if (!(pcidevs = virHostdevGetPciHostDeviceList(hostdevs, nhostdevs, drv_name))) > + goto cleanup; > + > + /* We have to use 9 loops here. *All* devices must > + * be detached before we reset any of them, because > + * in some cases you have to reset the whole PCI, > + * which impacts all devices on it. Also, all devices > + * must be reset before being marked as active. > + */ > + > + /* Loop 1: validate that non-managed device isn't in use, eg > + * by checking that device is either un-bound, or bound > + * to stub driver > + */ > + > + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); > + virPCIDevicePtr other; > + bool strict_acs_check = (flags & VIR_STRICT_ACS_CHECK)?true:false; > + > + if (!virPCIDeviceIsAssignable(dev, strict_acs_check)) { > + virReportError(VIR_ERR_OPERATION_INVALID, > + _("PCI device %s is not assignable"), > + virPCIDeviceGetName(dev)); > + goto cleanup; > + } > + /* The device is in use by other active domain if > + * the dev is in list activePciHostdevs. > + */ > + if ((other = virPCIDeviceListFind(mgr->activePciHostdevs, dev))) { > + char *other_drvname = NULL; > + char *other_domname = NULL; > + virPCIDeviceGetUsedBy(other, &other_drvname, &other_domname); > + > + if (other_drvname && other_domname) > + virReportError(VIR_ERR_OPERATION_INVALID, > + _("PCI device %s is in use by driver %s,domain %s"), > + virPCIDeviceGetName(dev), other_drvname, > + other_domname); > + else > + virReportError(VIR_ERR_OPERATION_INVALID, > + _("PCI device %s is already in use"), > + virPCIDeviceGetName(dev)); > + VIR_FREE(other_drvname); > + VIR_FREE(other_domname); > + goto cleanup; > + } > + } > + > + /* Loop 2: detach managed devices */ > + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); > + if (virPCIDeviceGetManaged(dev) && > + virPCIDeviceDetach(dev, mgr->activePciHostdevs, NULL) < 0) > + goto reattachdevs; > + } > + > + /* Loop 3: Now that all the PCI hostdevs have been detached, we > + * can safely reset them */ > + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); > + if (virPCIDeviceReset(dev, mgr->activePciHostdevs, > + mgr->inactivePciHostdevs) < 0) > + goto reattachdevs; > + } > + > + /* Loop 4: For SRIOV network devices, Now that we have detached the > + * the network device, set the netdev config */ > + for (i = 0; i < nhostdevs; i++) { > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) > + continue; > + if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) > + continue; > + if (hostdev->parent.type == VIR_DOMAIN_DEVICE_NET && > + hostdev->parent.data.net) { > + if (virHostdevNetConfigReplace(hostdev, uuid, > + mgr->stateDir) < 0) { > + goto resetvfnetconfig; > + } > + } > + last_processed_hostdev_vf = i; > + } > + > + /* Loop 5: Now mark all the devices as active */ > + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); > + if (virPCIDeviceListAdd(mgr->activePciHostdevs, dev) < 0) > + goto inactivedevs; > + } > + > + /* Loop 6: Now remove the devices from inactive list. */ > + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); > + virPCIDeviceListDel(mgr->inactivePciHostdevs, dev); > + } > + > + /* Loop 7: Now set the used_by_domain of the device in > + * driver->activePciHostdevs as domain name. > + */ > + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { > + virPCIDevicePtr dev, activeDev; > + > + dev = virPCIDeviceListGet(pcidevs, i); > + activeDev = virPCIDeviceListFind(mgr->activePciHostdevs, dev); > + > + if (activeDev) > + virPCIDeviceSetUsedBy(activeDev, drv_name, dom_name); > + } > + > + /* Loop 8: Now set the original states for hostdev def */ > + for (i = 0; i < nhostdevs; i++) { > + virPCIDevicePtr dev; > + virPCIDevicePtr pcidev; > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + > + if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) > + continue; > + if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) > + continue; > + > + dev = virPCIDeviceNew(hostdev->source.subsys.u.pci.addr.domain, > + hostdev->source.subsys.u.pci.addr.bus, > + hostdev->source.subsys.u.pci.addr.slot, > + hostdev->source.subsys.u.pci.addr.function); > + > + /* original states "unbind_from_stub", "remove_slot", > + * "reprobe" were already set by pciDettachDevice in > + * loop 2. > + */ > + if ((pcidev = virPCIDeviceListFind(pcidevs, dev))) { > + hostdev->origstates.states.pci.unbind_from_stub = > + virPCIDeviceGetUnbindFromStub(pcidev); > + hostdev->origstates.states.pci.remove_slot = > + virPCIDeviceGetRemoveSlot(pcidev); > + hostdev->origstates.states.pci.reprobe = > + virPCIDeviceGetReprobe(pcidev); > + } > + > + virPCIDeviceFree(dev); > + } > + > + /* Loop 9: Now steal all the devices from pcidevs */ > + 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 virObjectUnref(). > + */ > + while (virPCIDeviceListCount(pcidevs) > 0) { > + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, 0); > + virPCIDeviceListSteal(mgr->activePciHostdevs, dev); > + } > + > +resetvfnetconfig: > + for (i = 0; i < last_processed_hostdev_vf; i++) { > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + if (hostdev->parent.type == VIR_DOMAIN_DEVICE_NET && > + hostdev->parent.data.net) { > + virHostdevNetConfigRestore(hostdev, mgr->stateDir); > + } > + } > + > +reattachdevs: > + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); > + virPCIDeviceReattach(dev, mgr->activePciHostdevs, NULL); > + } > + > +cleanup: > + virObjectUnlock(mgr->activePciHostdevs); > + virObjectUnlock(mgr->inactivePciHostdevs); > + virObjectUnref(pcidevs); > + return ret; > +} > + > +static int > +virHostdevFindUSBDevice(virDomainHostdevDefPtr hostdev, > + bool mandatory, > + virUSBDevicePtr *usb) > +{ > + unsigned vendor = hostdev->source.subsys.u.usb.vendor; > + unsigned product = hostdev->source.subsys.u.usb.product; > + unsigned bus = hostdev->source.subsys.u.usb.bus; > + unsigned device = hostdev->source.subsys.u.usb.device; > + bool autoAddress = hostdev->source.subsys.u.usb.autoAddress; > + int rc; > + > + *usb = NULL; > + > + if (vendor && bus) { > + rc = virUSBDeviceFind(vendor, product, bus, device, > + NULL, > + autoAddress ? false : mandatory, > + usb); > + if (rc < 0) { > + return -1; > + } else if (!autoAddress) { > + goto out; > + } else { > + VIR_INFO("USB device %x:%x could not be found at previous" > + " address (bus:%u device:%u)", > + vendor, product, bus, device); > + } > + } > + > + /* When vendor is specified, its USB address is either unspecified or the > + * device could not be found at the USB device where it had been > + * automatically found before. > + */ > + if (vendor) { > + virUSBDeviceListPtr devs; > + > + rc = virUSBDeviceFindByVendor(vendor, product, NULL, mandatory, &devs); > + if (rc < 0) > + return -1; > + > + if (rc == 1) { > + *usb = virUSBDeviceListGet(devs, 0); > + virUSBDeviceListSteal(devs, *usb); > + } > + virObjectUnref(devs); > + > + if (rc == 0) { > + goto out; > + } else if (rc > 1) { > + if (autoAddress) { > + virReportError(VIR_ERR_OPERATION_FAILED, > + _("Multiple USB devices for %x:%x were found," > + " but none of them is at bus:%u device:%u"), > + vendor, product, bus, device); > + } else { > + virReportError(VIR_ERR_OPERATION_FAILED, > + _("Multiple USB devices for %x:%x, " > + "use <address> to specify one"), > + vendor, product); > + } > + return -1; > + } > + > + hostdev->source.subsys.u.usb.bus = virUSBDeviceGetBus(*usb); > + hostdev->source.subsys.u.usb.device = virUSBDeviceGetDevno(*usb); > + hostdev->source.subsys.u.usb.autoAddress = true; > + > + if (autoAddress) { > + VIR_INFO("USB device %x:%x found at bus:%u device:%u (moved" > + " from bus:%u device:%u)", > + vendor, product, > + hostdev->source.subsys.u.usb.bus, > + hostdev->source.subsys.u.usb.device, > + bus, device); > + } > + } else if (!vendor && bus) { > + if (virUSBDeviceFindByBus(bus, device, NULL, mandatory, usb) < 0) > + return -1; > + } > + > +out: > + if (!*usb) > + hostdev->missing = true; > + return 0; > +} > + > +static int > +virHostdevMarkUsbHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virUSBDeviceListPtr list) > +{ > + size_t i, j; > + unsigned int count; > + virUSBDevicePtr tmp; > + > + virObjectLock(mgr->activeUsbHostdevs); > + count = virUSBDeviceListCount(list); > + > + for (i = 0; i < count; i++) { > + virUSBDevicePtr usb = virUSBDeviceListGet(list, i); > + if ((tmp = virUSBDeviceListFind(mgr->activeUsbHostdevs, usb))) { > + char *other_drvname = NULL; > + char *other_domname = NULL; > + virUSBDeviceGetUsedBy(tmp, &other_drvname, &other_domname); > + > + if (other_drvname && other_domname) > + virReportError(VIR_ERR_OPERATION_INVALID, > + _("USB device %s is in use by driver %s,domain %s"), > + virUSBDeviceGetName(tmp), other_drvname, > + other_domname); > + else > + virReportError(VIR_ERR_OPERATION_INVALID, > + _("USB device %s is already in use"), > + virUSBDeviceGetName(tmp)); > + VIR_FREE(other_drvname); > + VIR_FREE(other_domname); > + goto error; > + } > + > + virUSBDeviceSetUsedBy(usb, drv_name, dom_name); > + VIR_DEBUG("Adding %03d.%03d driver= %s dom=%s to activeUsbHostdevs", > + virUSBDeviceGetBus(usb), virUSBDeviceGetDevno(usb),drv_name, dom_name); > Space between ',' and 'drv_name'. > + /* > + * The caller is responsible to steal these usb devices > + * from the virUSBDeviceList that passed in on success, > + * perform rollback on failure. > + */ > + if (virUSBDeviceListAdd(mgr->activeUsbHostdevs, usb) < 0) > + goto error; > + } > + > + virObjectUnlock(mgr->activeUsbHostdevs); > + return 0; > + > +error: > + for (j = 0; j < i; j++) { > + tmp = virUSBDeviceListGet(list, i); > + virUSBDeviceListSteal(mgr->activeUsbHostdevs, tmp); > + } > + virObjectUnlock(mgr->activeUsbHostdevs); > + return -1; > +} > + > +int > +virHostdevPrepareUsbHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs, > + bool coldBoot) > +{ > + size_t i; > + int ret = -1; > + virUSBDeviceListPtr list; > + virUSBDevicePtr tmp; > + > + /* To prevent situation where USB device is assigned to two domains > + * we need to keep a list of currently assigned USB devices. > + * This is done in several loops which cannot be joined into one > + * big loop. > + */ > + if (!(list = virUSBDeviceListNew())) > + goto cleanup; > + > + /* Loop 1: build temporary list > + */ > + for (i = 0; i < nhostdevs; i++) { > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + bool required = true; > + virUSBDevicePtr usb; > + > + if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) > + continue; > + if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) > + continue; > + > + if (hostdev->startupPolicy == VIR_DOMAIN_STARTUP_POLICY_OPTIONAL || > + (hostdev->startupPolicy == VIR_DOMAIN_STARTUP_POLICY_REQUISITE && > + !coldBoot)) > + required = false; > + > + if (virHostdevFindUSBDevice(hostdev, required, &usb) < 0) > + goto cleanup; > + > + if (usb && virUSBDeviceListAdd(list, usb) < 0) { > + virUSBDeviceFree(usb); > + goto cleanup; > + } > + } > + > + /* Mark devices in temporary list as used by @name > + * and add them do active list. However, if something goes > + * wrong, perform rollback. > + */ > + if (virHostdevMarkUsbHostdevs(mgr, drv_name, dom_name, list) < 0) > + goto cleanup; > + > + /* Loop 2: Temporary list was successfully merged with > + * active list, so steal all items to avoid freeing them > + * in cleanup label. > + */ > + while (virUSBDeviceListCount(list) > 0) { > + tmp = virUSBDeviceListGet(list, 0); > + virUSBDeviceListSteal(list, tmp); > + } > + > + ret = 0; > + > +cleanup: > + virObjectUnref(list); > + return ret; > +} > + > +int > +virHostdevPrepareScsiHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs) > +{ > + size_t i, j; > + int count; > + virSCSIDeviceListPtr list; > + virSCSIDevicePtr tmp; > + > + /* To prevent situation where SCSI device is assigned to two domains > + * we need to keep a list of currently assigned SCSI devices. > + */ > + if (!(list = virSCSIDeviceListNew())) > + goto cleanup; > + > + /* Loop 1: build temporary list */ > + for (i = 0; i < nhostdevs; i++) { > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + virSCSIDevicePtr scsi; > + > + if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS || > + hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI) > + continue; > + > + if (hostdev->managed) { > + virReportError(VIR_ERR_XML_ERROR, "%s", > + _("SCSI host device doesn't support managed mode")); > + goto cleanup; > + } > + > + if (!(scsi = virSCSIDeviceNew(hostdev->source.subsys.u.scsi.adapter, > + hostdev->source.subsys.u.scsi.bus, > + hostdev->source.subsys.u.scsi.target, > + hostdev->source.subsys.u.scsi.unit, > + hostdev->readonly))) > + goto cleanup; > + > + if (scsi && virSCSIDeviceListAdd(list, scsi) < 0) { > + virSCSIDeviceFree(scsi); > + goto cleanup; > + } > + } > + > + /* Loop 2: Mark devices in temporary list as used by > + * and add them to driver list. However, if something goes > + * wrong, perform rollback. > + */ > + virObjectLock(mgr->activeScsiHostdevs); > + count = virSCSIDeviceListCount(list); > + > + for (i = 0; i < count; i++) { > + virSCSIDevicePtr scsi = virSCSIDeviceListGet(list, i); > + if ((tmp = virSCSIDeviceListFind(mgr->activeScsiHostdevs, scsi))) { > + char *other_drvname = NULL; > + char *other_domname = NULL; > + virSCSIDeviceGetUsedBy(tmp, &other_drvname, &other_domname); > + > + if (other_drvname && other_domname) > + virReportError(VIR_ERR_OPERATION_INVALID, > + _("SCSI device %s is in use by driver %s domain %s"), > + virSCSIDeviceGetName(tmp), other_drvname, other_domname); > + else > + virReportError(VIR_ERR_OPERATION_INVALID, > + _("SCSI device %s is already in use"), > + virSCSIDeviceGetName(tmp)); > + goto error; > + } > + > + virSCSIDeviceSetUsedBy(scsi, drv_name, dom_name); > + VIR_DEBUG("Adding %s to activeScsiHostdevs", virSCSIDeviceGetName(scsi)); > + > + if (virSCSIDeviceListAdd(mgr->activeScsiHostdevs, scsi) < 0) > + goto error; > + } > + > + virObjectUnlock(mgr->activeScsiHostdevs); > + > + /* Loop 3: Temporary list was successfully merged with > + * driver list, so steal all items to avoid freeing them > + * when freeing temporary list. > + */ > + while (virSCSIDeviceListCount(list) > 0) { > + tmp = virSCSIDeviceListGet(list, 0); > + virSCSIDeviceListSteal(list, tmp); > + } > + > + virObjectUnref(list); > + return 0; > + > +error: > + for (j = 0; j < i; j++) { > + tmp = virSCSIDeviceListGet(list, i); > Shouldn't this be 'virSCSIDeviceListGet(list, j)'? > + virSCSIDeviceListSteal(mgr->activeScsiHostdevs, tmp); > + } > + virObjectUnlock(mgr->activeScsiHostdevs); > +cleanup: > + virObjectUnref(list); > + return -1; > +} > + > + > +int > +virHostdevPrepareDomainHostdevs(virHostdevManagerPtr mgr, > + const char *driver, > + virDomainDefPtr def, > + unsigned int flags) > Parameter whitespace alignment. > +{ > + if (!def->nhostdevs) > + return 0; > + > + if (flags & VIR_SP_PCI_HOSTDEV) { > + if (virHostdevPreparePciHostdevs(mgr, driver, > + def->name, def->uuid, > + def->hostdevs, > + def->nhostdevs, > + flags) < 0) > + return -1; > + } > + > + if (flags & VIR_SP_USB_HOSTDEV) { > + bool coldBoot = (flags & VIR_COLD_BOOT)?true:false; > + if (virHostdevPrepareUsbHostdevs(mgr, driver, def->name, > + def->hostdevs, def->nhostdevs, > + coldBoot) < 0) > + return -1; > + } > + > + if (flags & VIR_SP_SCSI_HOSTDEV) { > + if (virHostdevPrepareScsiHostdevs(mgr, driver, def->name, > + def->hostdevs, def->nhostdevs) < 0) > + return -1; > + } > + > + return 0; > +} > + > +/* > + * Pre-condition: mgr->inactivePciHostdevs & mgr->activePciHostdevs > + * are locked > + */ > +static void > +virHostdevReAttachPciDevice(virHostdevManagerPtr mgr, virPCIDevicePtr dev, const char *driver) > This line is > 80 columns. > +{ > + /* If the device is not managed and was attached to guest > + * successfully, it must have been inactive. > + */ > + if (!virPCIDeviceGetManaged(dev)) { > + if (virPCIDeviceListAdd(mgr->inactivePciHostdevs, dev) < 0) > + virPCIDeviceFree(dev); > + return; > + } > + > + /* Wait for device cleanup if it is qemu/kvm */ > + if (STREQ(driver, QEMU_DRIVER_NAME) && > + STREQ(virPCIDeviceGetStubDriver(dev), "pci-stub")) { > + int retries = 100; > + while (virPCIDeviceWaitForCleanup(dev, "kvm_assigned_device") > + && retries) { > + usleep(100*1000); > + retries--; > + } > + } > + > + if (virPCIDeviceReattach(dev, mgr->activePciHostdevs, > + mgr->inactivePciHostdevs) < 0) { > + virErrorPtr err = virGetLastError(); > + VIR_ERROR(_("Failed to re-attach PCI device: %s"), > + err ? err->message : _("unknown error")); > + virResetError(err); > + } > + virPCIDeviceFree(dev); > +} > + > +/* > + * Pre-condition: mgr->activePciHostdevs is locked > + */ > +static virPCIDeviceListPtr > +virHostdevGetActivePciHostDeviceList(virHostdevManagerPtr mgr, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs) > +{ > + virPCIDeviceListPtr list; > + size_t i; > + > + if (!(list = virPCIDeviceListNew())) > + return NULL; > + > + for (i = 0; i < nhostdevs; i++) { > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + 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 = virPCIDeviceNew(hostdev->source.subsys.u.pci.addr.domain, > + hostdev->source.subsys.u.pci.addr.bus, > + hostdev->source.subsys.u.pci.addr.slot, > + hostdev->source.subsys.u.pci.addr.function); > + if (!dev) { > + virObjectUnref(list); > + return NULL; > + } > + > + if ((activeDev = virPCIDeviceListFind(mgr->activePciHostdevs, dev))) { > + if (virPCIDeviceListAdd(list, activeDev) < 0) { > + virPCIDeviceFree(dev); > + virObjectUnref(list); > + return NULL; > + } > + } > + > + virPCIDeviceFree(dev); > + } > + > + return list; > +} > + > +void > +virHostdevReAttachPciHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs) > +{ > + virPCIDeviceListPtr pcidevs; > + size_t i; > + > + virObjectLock(mgr->activePciHostdevs); > + virObjectLock(mgr->inactivePciHostdevs); > + > + if (!(pcidevs = virHostdevGetActivePciHostDeviceList(mgr, > + hostdevs, > + nhostdevs))) { > + virErrorPtr err = virGetLastError(); > + VIR_ERROR(_("Failed to allocate PCI device list: %s"), > + err ? err->message : _("unknown error")); > + virResetError(err); > + goto cleanup; > + } > + > + /* Again 4 loops; mark all devices as inactive before reset > + * them and reset all the devices before re-attach. > + * Attach mac and port profile parameters to devices > + */ > + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); > + virPCIDevicePtr activeDev = NULL; > + char *usedby_drvname = NULL; > + char *usedby_domname = NULL; > + > + /* Never delete the dev from list driver->activePciHostdevs > + * if it's used by other domain. > + */ > + activeDev = virPCIDeviceListFind(mgr->activePciHostdevs, dev); > + if (activeDev) { > + if (virPCIDeviceGetUsedBy(activeDev, &usedby_drvname, &usedby_domname) < 0) { > + VIR_WARN("Unable to get driver and domain name " > + "using PCI device %s", > + virPCIDeviceGetName(dev)); > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + continue; > + } > + > + if (STRNEQ_NULLABLE(drv_name, usedby_drvname) || > + STRNEQ_NULLABLE(dom_name, usedby_domname)) { > + virPCIDeviceListSteal(pcidevs, dev); > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + continue; > + } > + } > + > + /* virObjectUnref() will take care of freeing the dev. */ > + virPCIDeviceListSteal(mgr->activePciHostdevs, dev); > + > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + } > + > + /* > + * For SRIOV net host devices, unset mac and port profile before > + * reset and reattach device > + */ > + for (i = 0; i < nhostdevs; i++) { > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) > + continue; > + if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) > + continue; > + if (hostdev->parent.type == VIR_DOMAIN_DEVICE_NET && > + hostdev->parent.data.net) { > + virHostdevNetConfigRestore(hostdev, mgr->stateDir); > + } > + } > + > + for (i = 0; i < virPCIDeviceListCount(pcidevs); i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(pcidevs, i); > + if (virPCIDeviceReset(dev, mgr->activePciHostdevs, > + mgr->inactivePciHostdevs) < 0) { > + virErrorPtr err = virGetLastError(); > + VIR_ERROR(_("Failed to reset PCI device: %s"), > + err ? err->message : _("unknown error")); > + virResetError(err); > + } > + } > + > + while (virPCIDeviceListCount(pcidevs) > 0) { > + virPCIDevicePtr dev = virPCIDeviceListStealIndex(pcidevs, 0); > + virHostdevReAttachPciDevice(mgr, dev, drv_name); > + } > + > + virObjectUnref(pcidevs); > +cleanup: > + virObjectUnlock(mgr->activePciHostdevs); > + virObjectUnlock(mgr->inactivePciHostdevs); > +} > + > +void > +virHostdevReAttachUsbHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs) > +{ > + size_t i; > + > + virObjectLock(mgr->activeUsbHostdevs); > + for (i = 0; i < nhostdevs; i++) { > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + virUSBDevicePtr usb, tmp; > + char *usedby_drvname = NULL; > + char *usedby_domname = NULL; > + > + if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) > + continue; > + if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) > + continue; > + if (hostdev->missing) > + continue; > + > + usb = virUSBDeviceNew(hostdev->source.subsys.u.usb.bus, > + hostdev->source.subsys.u.usb.device, > + NULL); > + > + if (!usb) { > + VIR_WARN("Unable to reattach USB device %03d.%03d on driver %s domain %s", > + hostdev->source.subsys.u.usb.bus, > + hostdev->source.subsys.u.usb.device, > + drv_name, dom_name); > + continue; > + } > + > + /* Delete only those USB devices which belongs > + * to domain. Therefore we want to steal only > + * those devices from the list which were taken > + * by domain */ > + > + tmp = virUSBDeviceListFind(mgr->activeUsbHostdevs, usb); > + virUSBDeviceFree(usb); > + > + if (!tmp) { > + VIR_WARN("Unable to find device %03d.%03d " > + "in list of active USB devices", > + hostdev->source.subsys.u.usb.bus, > + hostdev->source.subsys.u.usb.device); > + continue; > + } > + > + if (virUSBDeviceGetUsedBy(tmp, &usedby_drvname, &usedby_domname) < 0) { > + VIR_WARN("Unable to get driver and domain name " > + "using USB device %03d.%03d", > + hostdev->source.subsys.u.usb.bus, > + hostdev->source.subsys.u.usb.device); > + > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + continue; > + } > + > + if (STREQ_NULLABLE(drv_name, usedby_drvname) && > + STREQ_NULLABLE(dom_name, usedby_domname)) { > + VIR_DEBUG("Removing %03d.%03d dom=%s:%s", > + hostdev->source.subsys.u.usb.bus, > + hostdev->source.subsys.u.usb.device, > + drv_name, dom_name); > + virUSBDeviceListDel(mgr->activeUsbHostdevs, tmp); > + } > + > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + > + } > + > + virObjectUnlock(mgr->activeUsbHostdevs); > +} > + > +void > +virHostdevReAttachScsiHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs) > +{ > + size_t i; > + > + virObjectLock(mgr->activeScsiHostdevs); > + for (i = 0; i < nhostdevs; i++) { > + virDomainHostdevDefPtr hostdev = hostdevs[i]; > + virSCSIDevicePtr scsi, tmp; > + char *usedby_drvname = NULL; > + char *usedby_domname = NULL; > + > + if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS || > + hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI) > + continue; > + > + if (!(scsi = virSCSIDeviceNew(hostdev->source.subsys.u.scsi.adapter, > + hostdev->source.subsys.u.scsi.bus, > + hostdev->source.subsys.u.scsi.target, > + hostdev->source.subsys.u.scsi.unit, > + hostdev->readonly))) { > + VIR_WARN("Unable to reattach SCSI device %s:%d:%d:%d on driver %s domain %s", > + hostdev->source.subsys.u.scsi.adapter, > + hostdev->source.subsys.u.scsi.bus, > + hostdev->source.subsys.u.scsi.target, > + hostdev->source.subsys.u.scsi.unit, > + drv_name, dom_name); > + continue; > + } > + > + tmp = virSCSIDeviceListFind(mgr->activeScsiHostdevs, scsi); > + virSCSIDeviceFree(scsi); > + > + if (!tmp) { > + VIR_WARN("Unable to find device %s:%d:%d:%d " > + "in list of active SCSI devices", > + hostdev->source.subsys.u.scsi.adapter, > + hostdev->source.subsys.u.scsi.bus, > + hostdev->source.subsys.u.scsi.target, > + hostdev->source.subsys.u.scsi.unit); > + continue; > + } > + > + if (virSCSIDeviceGetUsedBy(tmp, &usedby_drvname, &usedby_domname) < 0) { > + VIR_WARN("Unable to get driver and domain name " > + "using SCSI device %s:%d:%d:%d ", > + hostdev->source.subsys.u.scsi.adapter, > + hostdev->source.subsys.u.scsi.bus, > + hostdev->source.subsys.u.scsi.target, > + hostdev->source.subsys.u.scsi.unit); > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + continue; > + } > + > + if (STREQ_NULLABLE(usedby_drvname, drv_name) && > + STREQ_NULLABLE(usedby_domname, dom_name)) { > + VIR_DEBUG("Removing %s:%d:%d:%d driver:%s dom:%s from activeScsiHostdevs", > + hostdev->source.subsys.u.scsi.adapter, > + hostdev->source.subsys.u.scsi.bus, > + hostdev->source.subsys.u.scsi.target, > + hostdev->source.subsys.u.scsi.unit, > + drv_name, dom_name); > + virSCSIDeviceListDel(mgr->activeScsiHostdevs, tmp); > + } > + > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + } > + > + virObjectUnlock(mgr->activeScsiHostdevs); > +} > + > +void > +virHostdevReAttachDomainHostdevs(virHostdevManagerPtr mgr, > + const char *driver, > + virDomainDefPtr def, > + unsigned int flags) > Parameter whitespace alignment. > +{ > + if (!def->nhostdevs) > + return; > + > + if (flags & VIR_SP_PCI_HOSTDEV) { > + virHostdevReAttachPciHostdevs(mgr, driver, def->name, def->hostdevs, def->nhostdevs); > + } > + > + if (flags & VIR_SP_USB_HOSTDEV) { > + virHostdevReAttachUsbHostdevs(mgr, driver, def->name, def->hostdevs, def->nhostdevs); > + } > + > + if (flags & VIR_SP_SCSI_HOSTDEV) { > + virHostdevReAttachScsiHostdevs(mgr, driver, def->name, def->hostdevs, def->nhostdevs); > + } > +} > + > +/* following functions are used by NodeDevDetach/Reattach/Reset */ > +int > +virHostdevPciNodeDeviceDetach(virHostdevManagerPtr mgr, > + virPCIDevicePtr pci) > +{ > + int ret; > Needs a line after local variable declaration. > + virObjectLock(mgr->activePciHostdevs); > + virObjectLock(mgr->inactivePciHostdevs); > + if (virPCIDeviceDetach(pci, mgr->activePciHostdevs, > + mgr->inactivePciHostdevs) < 0) > + ret = -1; > + else > + ret = 0; > + > + virObjectUnlock(mgr->inactivePciHostdevs); > + virObjectUnlock(mgr->activePciHostdevs); > + return ret; > +} > + > +int > +virHostdevPciNodeDeviceReAttach(virHostdevManagerPtr mgr, > + virPCIDevicePtr pci) > +{ > + int ret = -1; > + virPCIDevicePtr other; > + > + virObjectLock(mgr->activePciHostdevs); > + virObjectLock(mgr->inactivePciHostdevs); > + other = virPCIDeviceListFind(mgr->activePciHostdevs, pci); > + if (other) { > + char *other_drvname = NULL; > + char *other_domname = NULL; > + virPCIDeviceGetUsedBy(other, &other_drvname, &other_domname); > + > + if (other_drvname && other_domname) > + virReportError(VIR_ERR_OPERATION_INVALID, > + _("PCI device %s is still in use by driver %s, domain %s"), > + virPCIDeviceGetName(pci), other_drvname, other_domname); > + else > + virReportError(VIR_ERR_OPERATION_INVALID, > + _("PCI device %s is still in use"), > + virPCIDeviceGetName(pci)); > + goto out; > + } > + > + virPCIDeviceReattachInit(pci); > + > + if (virPCIDeviceReattach(pci, mgr->activePciHostdevs, > + mgr->inactivePciHostdevs) < 0) > + goto out; > + > + ret = 0; > +out: > + virObjectUnlock(mgr->inactivePciHostdevs); > + virObjectUnlock(mgr->activePciHostdevs); > + return ret; > +} > + > +int > +virHostdevPciNodeDeviceReset(virHostdevManagerPtr mgr, > + virPCIDevicePtr pci) > +{ > + int ret; > Needs line after local variable declaration. > + virObjectLock(mgr->activePciHostdevs); > + virObjectLock(mgr->inactivePciHostdevs); > + if (virPCIDeviceReset(pci, mgr->activePciHostdevs, > + mgr->inactivePciHostdevs) < 0) > + ret = -1; > + else > + ret = 0; > + > + virObjectUnlock(mgr->inactivePciHostdevs); > + virObjectUnlock(mgr->activePciHostdevs); > + return ret; > +} > + > +/* this function is used to free memory after using following > + * get_active/inactive_list functions > + */ > +void > +virHostdevNameListFree(virHostdevNameListPtr list) > +{ > + size_t i; > + > + if (list && list->names) { > + for (i = 0; i < list->nnames; i++) { > + VIR_FREE(list->names[i]); > + } > + VIR_FREE(list->names); > + } > + VIR_FREE(list); > +} > + > +virHostdevNameListPtr > +virHostdevGetActivePciHostdevs(virHostdevManagerPtr mgr) > +{ > + size_t i; > + int count; > + virHostdevNameListPtr list = NULL; > + virObjectLock(mgr->activePciHostdevs); > + > + count = virPCIDeviceListCount(mgr->activePciHostdevs); > + if (count > 0) { > + if (VIR_ALLOC_N(list, 1) < 0) { > + virReportOOMError(); > No need to explicitly report OOM error now. > + goto cleanup; > + } > + > + if (VIR_ALLOC_N(list->names,count) < 0) { > + virReportOOMError(); > Same here. > + goto cleanup; > + } > + list->nnames = 0; > + > + for (i = 0; i < count; i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(mgr->activePciHostdevs, i); > + if (VIR_STRDUP(list->names[list->nnames++], virPCIDeviceGetName(dev)) < 0) > + goto cleanup; > + } > + } > + > + goto end; > + > +cleanup: > + virHostdevNameListFree(list); > + > +end: > + virObjectUnlock(mgr->activePciHostdevs); > + return list; > +} > + > +virHostdevNameListPtr > +virHostdevGetActiveUsbHostdevs(virHostdevManagerPtr mgr) > +{ > + size_t i; > + int count; > + virHostdevNameListPtr list = NULL; > + virObjectLock(mgr->activeUsbHostdevs); > + > + count = virUSBDeviceListCount(mgr->activeUsbHostdevs); > + if (count > 0) { > + if (VIR_ALLOC_N(list, 1) < 0) { > + virReportOOMError(); > Same, no need for OOM error reporting. > + goto cleanup; > + } > + > + if (VIR_ALLOC_N(list->names,count) < 0) { > + virReportOOMError(); > And again. > + goto cleanup; > + } > + list->nnames = 0; > + > + for (i = 0; i < count; i++) { > + virUSBDevicePtr usb = virUSBDeviceListGet(mgr->activeUsbHostdevs, i); > + if (VIR_STRDUP(list->names[list->nnames++], virUSBDeviceGetName(usb)) < 0) > + goto cleanup; > + } > + } > + > + goto end; > + > +cleanup: > + virHostdevNameListFree(list); > +end: > + virObjectUnlock(mgr->activeUsbHostdevs); > + return list; > +} > + > +virHostdevNameListPtr > +virHostdevGetActiveScsiHostdevs(virHostdevManagerPtr mgr) > +{ > + size_t i; > + int count; > + virHostdevNameListPtr list = NULL; > + virObjectLock(mgr->activeScsiHostdevs); > + > + count = virSCSIDeviceListCount(mgr->activeScsiHostdevs); > + if (count > 0) { > + if (VIR_ALLOC_N(list, 1) < 0) { > + virReportOOMError(); > And again. > + goto cleanup; > + } > + > + if (VIR_ALLOC_N(list->names,count) < 0) { > + virReportOOMError(); > Here too. > + goto cleanup; > + } > + list->nnames = 0; > + > + for (i = 0; i < count; i++) { > + virSCSIDevicePtr dev = virSCSIDeviceListGet(mgr->activeScsiHostdevs, i); > + if (VIR_STRDUP(list->names[list->nnames++], virSCSIDeviceGetName(dev)) < 0) > + goto cleanup; > + } > + } > + > + goto end; > + > +cleanup: > + virHostdevNameListFree(list); > +end: > + virObjectUnlock(mgr->activeScsiHostdevs); > + return list; > +} > + > +virHostdevNameListPtr > +virHostdevGetDomainActivePciHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name) > +{ > + size_t i, count; > + virHostdevNameListPtr list = NULL; > + virObjectLock(mgr->activePciHostdevs); > + > + count = virPCIDeviceListCount(mgr->activePciHostdevs); > + if (count > 0) { > + if (VIR_ALLOC_N(list, 1) < 0) { > + virReportOOMError(); > Same. > + goto cleanup; > + } > + > + if (VIR_ALLOC_N(list->names,count) < 0) { > + virReportOOMError(); > Same. > + goto cleanup; > + } > + list->nnames = 0; > + > + for (i = 0; i < count; i++) { > + virPCIDevicePtr dev = virPCIDeviceListGet(mgr->activePciHostdevs, i); > + char *usedby_drvname = NULL; > + char *usedby_domname = NULL; > + int ret; > + > + if (virPCIDeviceGetUsedBy(dev, &usedby_drvname, &usedby_domname) < 0) { > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + > + goto cleanup; > + } > + > + if (STREQ(drv_name, usedby_drvname) && > + STREQ(dom_name, usedby_domname)) { > + ret = VIR_STRDUP(list->names[list->nnames++], virPCIDeviceGetName(dev)); > + if (ret < 0) { > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + goto cleanup; > + } > + } > + > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + } > + > + VIR_SHRINK_N(list->names, count, count - list->nnames); > + } > + > + goto end; > + > +cleanup: > + virHostdevNameListFree(list); > +end: > + virObjectUnlock(mgr->activePciHostdevs); > + return list; > +} > + > +virHostdevNameListPtr > +virHostdevGetDomainActiveUsbHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name) > +{ > + size_t i, count; > + virHostdevNameListPtr list = NULL; > + virObjectLock(mgr->activeUsbHostdevs); > + > + count = virUSBDeviceListCount(mgr->activeUsbHostdevs); > + if (count > 0) { > + if (VIR_ALLOC_N(list, 1) < 0) { > + virReportOOMError(); > + goto cleanup; > + } > + > + if (VIR_ALLOC_N(list->names,count) < 0) { > + virReportOOMError(); > A few more cases of unneeded OOM error reporting. > + goto cleanup; > + } > + list->nnames = 0; > + > + for (i = 0; i < count; i++) { > + virUSBDevicePtr usb = virUSBDeviceListGet(mgr->activeUsbHostdevs, i); > + char *usedby_drvname = NULL; > + char *usedby_domname = NULL; > + int ret; > + > + if (virUSBDeviceGetUsedBy(usb, &usedby_drvname, &usedby_domname) < 0) { > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + goto cleanup; > + } > + > + if (STREQ(drv_name, usedby_drvname) && > + STREQ(dom_name, usedby_domname)) { > + ret = VIR_STRDUP(list->names[list->nnames++], virUSBDeviceGetName(usb)); > + if (ret < 0) { > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + goto cleanup; > + } > + } > + > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + } > + > + VIR_SHRINK_N(list->names, count, count - list->nnames); > + } > + > + goto end; > + > +cleanup: > + virHostdevNameListFree(list); > +end: > + virObjectUnlock(mgr->activeUsbHostdevs); > + return list; > +} > + > +virHostdevNameListPtr > +virHostdevGetDomainActiveScsiHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name) > +{ > + size_t i, count; > + virHostdevNameListPtr list = NULL; > + virObjectLock(mgr->activeScsiHostdevs); > + > + count = virSCSIDeviceListCount(mgr->activeScsiHostdevs); > + if (count > 0) { > + if (VIR_ALLOC_N(list, 1) < 0) { > + virReportOOMError(); > + goto cleanup; > + } > + > + if (VIR_ALLOC_N(list->names,count) < 0) { > + virReportOOMError(); > You're probably getting tired of this comment by now :). > + goto cleanup; > + } > + list->nnames = 0; > + > + for (i = 0; i < count; i++) { > + virSCSIDevicePtr dev = virSCSIDeviceListGet(mgr->activeScsiHostdevs, i); > + char *usedby_drvname = NULL; > + char *usedby_domname = NULL; > + int ret; > + > + if (virSCSIDeviceGetUsedBy(dev, &usedby_drvname, &usedby_domname) < 0) { > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + goto cleanup; > + } > + > + if (STREQ(drv_name, usedby_drvname) && > + STREQ(dom_name, usedby_domname)) { > + ret = VIR_STRDUP(list->names[list->nnames++], virSCSIDeviceGetName(dev)); > + if (ret < 0){ > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + goto cleanup; > + } > + } > + > + VIR_FREE(usedby_drvname); > + VIR_FREE(usedby_domname); > + } > + > + VIR_SHRINK_N(list->names, count, count - list->nnames); > + } > + > + goto end; > + > +cleanup: > + virHostdevNameListFree(list); > +end: > + virObjectUnlock(mgr->activeScsiHostdevs); > + return list; > +} > diff --git a/src/util/virhostdev.h b/src/util/virhostdev.h > new file mode 100644 > index 0000000..09377db > --- /dev/null > +++ b/src/util/virhostdev.h > @@ -0,0 +1,123 @@ > +/* virhostdev.h: hostdev management > + * > + * Copyright (C) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. > + * Copyright (C) 2006-2007, 2009-2013 Red Hat, Inc. > + * Copyright (C) 2006 Daniel P. Berrange > + * > + * This library is free software; you can redistribute it and/or > + * modify it under the terms of the GNU Lesser General Public > + * License as published by the Free Software Foundation; either > + * version 2.1 of the License, or (at your option) any later version. > + * > + * This library is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * Lesser General Public License for more details. > + * > + * You should have received a copy of the GNU Lesser General Public > + * License along with this library. If not, see > + * <http://www.gnu.org/licenses/>. > + * > + * Author: Chunyan Liu <cyliu@xxxxxxxx> > + * Author: Daniel P. Berrange <berrange@xxxxxxxxxx> > + */ > + > +#ifndef __VIR_HOSTDEV_MANAGER_H__ > +# define __VIR_HOSTDEV_MANAGER_H__ > + > +# include "internal.h" > +# include "configmake.h" > + > +# include "domain_conf.h" > +# include "virpci.h" > + > +# define HOSTDEV_STATE_DIR LOCALSTATEDIR "/run/libvirt/hostdevmanager" > This could be moved to virhostdev.c right? > + > +typedef enum { > + VIR_SP_PCI_HOSTDEV = (1 << 0), /* support pci passthrough */ > + VIR_SP_USB_HOSTDEV = (1 << 1), /* support usb passthrough */ > + VIR_SP_SCSI_HOSTDEV = (1 << 2), /* support scsi passthrough */ > + > + VIR_COLD_BOOT = (1 << 8), /* cold boot */ > + VIR_STRICT_ACS_CHECK = (1 << 9), /* strict acs check */ > +} virHostdevManagerFlag; > + > +typedef struct _virHostdevManager virHostdevManager; > +typedef virHostdevManager *virHostdevManagerPtr; > + > +struct virHostdevNameList { > + char **names; > + size_t nnames; > +}; > +typedef struct virHostdevNameList *virHostdevNameListPtr; > + > +virHostdevManagerPtr virHostdevManagerGetDefault(void); > + > +/* functions used to prepare/unprepare hostdevs for domain */ > +int virHostdevPrepareDomainHostdevs(virHostdevManagerPtr mgr, > + const char *driver, > + virDomainDefPtr def, > + unsigned int flags); > +void virHostdevReAttachDomainHostdevs(virHostdevManagerPtr mgr, > + const char *driver, > + virDomainDefPtr def, > + unsigned int flags); > Parameter whitespace alignment in these two function declarations. > +int virHostdevPreparePciHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + const unsigned char *uuid, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs, > + unsigned int flags); > +int virHostdevPrepareUsbHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs, > + bool coldBoot); > +int virHostdevPrepareScsiHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs); > +void virHostdevReAttachPciHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs); > +void virHostdevReAttachUsbHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs); > +void virHostdevReAttachScsiHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name, > + virDomainHostdevDefPtr *hostdevs, > + int nhostdevs); > + > +/* functions used by NodeDevDetach/Reattach/Reset */ > +int virHostdevPciNodeDeviceDetach(virHostdevManagerPtr mgr, > + virPCIDevicePtr pci); > +int virHostdevPciNodeDeviceReAttach(virHostdevManagerPtr mgr, > + virPCIDevicePtr pci); > +int virHostdevPciNodeDeviceReset(virHostdevManagerPtr mgr, > + virPCIDevicePtr pci); > + > +/* functions to get active/inactive lists */ > +virHostdevNameListPtr virHostdevGetActivePciHostdevs(virHostdevManagerPtr mgr); > +virHostdevNameListPtr virHostdevGetActiveUsbHostdevs(virHostdevManagerPtr mgr); > +virHostdevNameListPtr virHostdevGetActiveScsiHostdevs(virHostdevManagerPtr mgr); > +virHostdevNameListPtr virHostdevGetDomainActivePciHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name); > +virHostdevNameListPtr virHostdevGetDomainActiveUsbHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name); > +virHostdevNameListPtr virHostdevGetDomainActiveScsiHostdevs(virHostdevManagerPtr mgr, > + const char *drv_name, > + const char *dom_name); > +/* function to free memory after get active/inactive lists */ > +void virHostdevNameListFree(virHostdevNameListPtr list); > + > +#endif /* __VIR_HOSTDEV_MANAGER_H__ */ > diff --git a/src/util/virpci.c b/src/util/virpci.c > index be50b4f..dc38efe 100644 > --- a/src/util/virpci.c > +++ b/src/util/virpci.c > @@ -62,7 +62,10 @@ struct _virPCIDevice { > char name[PCI_ADDR_LEN]; /* domain:bus:slot.function */ > char id[PCI_ID_LEN]; /* product vendor */ > char *path; > - const char *used_by; /* The domain which uses the device */ > + > + /* The driver:domain which uses the device */ > + const char *used_by_drvname; > + const char *used_by_domname; > > unsigned int pcie_cap_pos; > unsigned int pci_pm_cap_pos; > @@ -1642,15 +1645,21 @@ virPCIDeviceSetReprobe(virPCIDevicePtr dev, bool reprobe) > } > > void > -virPCIDeviceSetUsedBy(virPCIDevicePtr dev, const char *name) > +virPCIDeviceSetUsedBy(virPCIDevicePtr dev, const char *drv_name, const char *dom_name) > { > - dev->used_by = name; > + dev->used_by_drvname = drv_name; > + dev->used_by_domname = dom_name; > } > > -const char * > -virPCIDeviceGetUsedBy(virPCIDevicePtr dev) > +int > +virPCIDeviceGetUsedBy(virPCIDevicePtr dev, char **drv_name, char **dom_name) > { > - return dev->used_by; > + if (VIR_STRDUP(*drv_name, dev->used_by_drvname) < 0) > + return -1; > + if (VIR_STRDUP(*dom_name, dev->used_by_domname) < 0) > + return -1; > + > + return 0; > } > > void virPCIDeviceReattachInit(virPCIDevicePtr pci) > diff --git a/src/util/virpci.h b/src/util/virpci.h > index 0aa6fee..dc1a80b 100644 > --- a/src/util/virpci.h > +++ b/src/util/virpci.h > @@ -66,8 +66,11 @@ int virPCIDeviceSetStubDriver(virPCIDevicePtr dev, > const char *driver); > const char *virPCIDeviceGetStubDriver(virPCIDevicePtr dev); > void virPCIDeviceSetUsedBy(virPCIDevice *dev, > - const char *used_by); > -const char *virPCIDeviceGetUsedBy(virPCIDevice *dev); > + const char *drv_name, > + const char *dom_name); > +int virPCIDeviceGetUsedBy(virPCIDevice *dev, > + char **drv_name, > + char **dom_name); > Parameters not aligned properly in these two function declarations. > unsigned int virPCIDeviceGetUnbindFromStub(virPCIDevicePtr dev); > void virPCIDeviceSetUnbindFromStub(virPCIDevice *dev, > bool unbind); > diff --git a/src/util/virscsi.c b/src/util/virscsi.c > index 32e438b..dc1eebb 100644 > --- a/src/util/virscsi.c > +++ b/src/util/virscsi.c > @@ -55,7 +55,10 @@ struct _virSCSIDevice { > char *name; /* adapter:bus:target:unit */ > char *id; /* model:vendor */ > char *sg_path; /* e.g. /dev/sg2 */ > - const char *used_by; /* name of the domain using this dev */ > + > + /* driver:domain using this dev */ > + const char *used_by_drvname; > + const char *used_by_domname; > > bool readonly; > }; > @@ -267,15 +270,22 @@ virSCSIDeviceFree(virSCSIDevicePtr dev) > > void > virSCSIDeviceSetUsedBy(virSCSIDevicePtr dev, > - const char *name) > + const char *drvname, > + const char *domname) > { > - dev->used_by = name; > + dev->used_by_drvname = drvname; > + dev->used_by_domname = domname; > } > > -const char * > -virSCSIDeviceGetUsedBy(virSCSIDevicePtr dev) > +int > +virSCSIDeviceGetUsedBy(virSCSIDevicePtr dev, char **drvname, char **domname) > { > - return dev->used_by; > + if (VIR_STRDUP(*drvname, dev->used_by_drvname) < 0) > + return -1; > + if (VIR_STRDUP(*domname, dev->used_by_domname) < 0) > + return -1; > + > + return 0; > } > > const char * > diff --git a/src/util/virscsi.h b/src/util/virscsi.h > index cce5df4..89b3e5d 100644 > --- a/src/util/virscsi.h > +++ b/src/util/virscsi.h > @@ -49,8 +49,12 @@ virSCSIDevicePtr virSCSIDeviceNew(const char *adapter, > bool readonly); > > void virSCSIDeviceFree(virSCSIDevicePtr dev); > -void virSCSIDeviceSetUsedBy(virSCSIDevicePtr dev, const char *name); > -const char *virSCSIDeviceGetUsedBy(virSCSIDevicePtr dev); > +void virSCSIDeviceSetUsedBy(virSCSIDevicePtr dev, > + const char *drvname, > + const char *domname); > +int virSCSIDeviceGetUsedBy(virSCSIDevicePtr dev, > + char **drvname, > + char **domname); > const char *virSCSIDeviceGetName(virSCSIDevicePtr dev); > unsigned int virSCSIDeviceGetAdapter(virSCSIDevicePtr dev); > unsigned int virSCSIDeviceGetBus(virSCSIDevicePtr dev); > diff --git a/src/util/virusb.c b/src/util/virusb.c > index e901618..54d836d 100644 > --- a/src/util/virusb.c > +++ b/src/util/virusb.c > @@ -55,7 +55,10 @@ struct _virUSBDevice { > char name[USB_ADDR_LEN]; /* domain:bus:slot.function */ > char id[USB_ID_LEN]; /* product vendor */ > char *path; > - const char *used_by; /* name of the domain using this dev */ > + > + /* driver:domain using this dev */ > + const char *used_by_drvname; > + const char *used_by_domname; > }; > > struct _virUSBDeviceList { > @@ -378,16 +381,24 @@ virUSBDeviceFree(virUSBDevicePtr dev) > VIR_FREE(dev); > } > > - > void virUSBDeviceSetUsedBy(virUSBDevicePtr dev, > - const char *name) > + const char *drv_name, > + const char *dom_name) > { > - dev->used_by = name; > + dev->used_by_drvname = drv_name; > + dev->used_by_domname = dom_name; > } > > -const char * virUSBDeviceGetUsedBy(virUSBDevicePtr dev) > +int virUSBDeviceGetUsedBy(virUSBDevicePtr dev, > + char **drv_name, > + char **dom_name) > Parameter alignment. This patch is looking good, but since I'm not terribly familiar with this area of libvirt and historically there have been quite a few bugs related to passthrough, it would be best if one of the devs familiar with this code (Laine, Osier) could also review it. Regards, Jim > { > - return dev->used_by; > + if (VIR_STRDUP(*drv_name, dev->used_by_drvname) < 0) > + return -1; > + if (VIR_STRDUP(*dom_name, dev->used_by_domname) < 0) > + return -1; > + > + return 0; > } > > const char *virUSBDeviceGetName(virUSBDevicePtr dev) > diff --git a/src/util/virusb.h b/src/util/virusb.h > index aa59d12..5f1df58 100644 > --- a/src/util/virusb.h > +++ b/src/util/virusb.h > @@ -60,8 +60,12 @@ int virUSBDeviceFind(unsigned int vendor, > virUSBDevicePtr *usb); > > void virUSBDeviceFree(virUSBDevicePtr dev); > -void virUSBDeviceSetUsedBy(virUSBDevicePtr dev, const char *name); > -const char *virUSBDeviceGetUsedBy(virUSBDevicePtr dev); > +void virUSBDeviceSetUsedBy(virUSBDevicePtr dev, > + const char *drv_name, > + const char *dom_name); > +int virUSBDeviceGetUsedBy(virUSBDevicePtr dev, > + char **drv_name, > + char **dom_name); > const char *virUSBDeviceGetName(virUSBDevicePtr dev); > > unsigned int virUSBDeviceGetBus(virUSBDevicePtr dev); > -- libvir-list mailing list libvir-list@xxxxxxxxxx https://www.redhat.com/mailman/listinfo/libvir-list