#define VIR_FROM_THIS VIR_FROM_DEVICE
-VIR_ENUM_IMPL(virDeviceAddressPciMulti,
+VIR_ENUM_IMPL(virDeviceAddressPCIMulti,
VIR_DEVICE_ADDRESS_PCI_MULTI_LAST,
"default",
"on",
}
if (multi &&
- ((addr->multi = virDeviceAddressPciMultiTypeFromString(multi)) <= 0)) {
+ ((addr->multi = virDeviceAddressPCIMultiTypeFromString(multi)) <= 0)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Unknown value '%s' for <address> 'multifunction' attribute"),
multi);
# include "virthread.h"
# include "virbuffer.h"
-enum virDeviceAddressPciMulti {
+enum virDeviceAddressPCIMulti {
VIR_DEVICE_ADDRESS_PCI_MULTI_DEFAULT = 0,
VIR_DEVICE_ADDRESS_PCI_MULTI_ON,
VIR_DEVICE_ADDRESS_PCI_MULTI_OFF,
unsigned int bus;
unsigned int slot;
unsigned int function;
- int multi; /* enum virDomainDeviceAddressPciMulti */
+ int multi; /* enum virDomainDeviceAddressPCIMulti */
};
int virDevicePCIAddressIsValid(virDevicePCIAddressPtr addr);
virDevicePCIAddress *addr2);
-VIR_ENUM_DECL(virDeviceAddressPciMulti)
+VIR_ENUM_DECL(virDeviceAddressPCIMulti)
#endif /* __DEVICE_CONF_H__ */
"pci",
"scsi")
-VIR_ENUM_IMPL(virDomainHostdevSubsysPciBackend,
+VIR_ENUM_IMPL(virDomainHostdevSubsysPCIBackend,
VIR_DOMAIN_HOSTDEV_PCI_BACKEND_TYPE_LAST,
"default",
"kvm",
"misc",
"net")
-VIR_ENUM_IMPL(virDomainPciRombarMode,
+VIR_ENUM_IMPL(virDomainPCIRombarMode,
VIR_DOMAIN_PCI_ROMBAR_LAST,
"default",
"on",
virBufferAddLit(buf, "<rom");
if (info->rombar) {
- const char *rombar = virDomainPciRombarModeTypeToString(info->rombar);
+ const char *rombar = virDomainPCIRombarModeTypeToString(info->rombar);
if (!rombar) {
virReportError(VIR_ERR_INTERNAL_ERROR,
info->addr.pci.function);
if (info->addr.pci.multi) {
virBufferAsprintf(buf, " multifunction='%s'",
- virDeviceAddressPciMultiTypeToString(info->addr.pci.multi));
+ virDeviceAddressPCIMultiTypeToString(info->addr.pci.multi));
}
break;
if (rom) {
char *rombar = virXMLPropString(rom, "bar");
if (rombar &&
- ((info->rombar = virDomainPciRombarModeTypeFromString(rombar)) <= 0)) {
+ ((info->rombar = virDomainPCIRombarModeTypeFromString(rombar)) <= 0)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown rom bar value '%s'"), rombar);
VIR_FREE(rombar);
* </origstates>
*/
static int
-virDomainHostdevSubsysPciOrigStatesDefParseXML(xmlNodePtr node,
+virDomainHostdevSubsysPCIOrigStatesDefParseXML(xmlNodePtr node,
virDomainHostdevOrigStatesPtr def)
{
xmlNodePtr cur;
}
static int
-virDomainHostdevSubsysPciDefParseXML(xmlNodePtr node,
+virDomainHostdevSubsysPCIDefParseXML(xmlNodePtr node,
virDomainHostdevDefPtr def,
unsigned int flags)
{
} else if ((flags & VIR_DOMAIN_XML_INTERNAL_PCI_ORIG_STATES) &&
xmlStrEqual(cur->name, BAD_CAST "origstates")) {
virDomainHostdevOrigStatesPtr states = &def->origstates;
- if (virDomainHostdevSubsysPciOrigStatesDefParseXML(cur, states) < 0)
+ if (virDomainHostdevSubsysPCIOrigStatesDefParseXML(cur, states) < 0)
goto out;
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
switch (def->source.subsys.type) {
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
- if (virDomainHostdevSubsysPciDefParseXML(sourcenode, def, flags) < 0)
+ if (virDomainHostdevSubsysPCIDefParseXML(sourcenode, def, flags) < 0)
goto error;
backend = VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT;
if ((backendStr = virXPathString("string(./driver/@name)", ctxt)) &&
- (((backend = virDomainHostdevSubsysPciBackendTypeFromString(backendStr)) < 0) ||
+ (((backend = virDomainHostdevSubsysPCIBackendTypeFromString(backendStr)) < 0) ||
backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Unknown PCI device <driver name='%s'/> "
{
if (def->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
def->source.subsys.u.pci.backend != VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT) {
- const char *backend = virDomainHostdevSubsysPciBackendTypeToString(def->source.subsys.u.pci.backend);
+ const char *backend = virDomainHostdevSubsysPCIBackendTypeToString(def->source.subsys.u.pci.backend);
if (!backend) {
virReportError(VIR_ERR_INTERNAL_ERROR,
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_LAST
};
-enum virDomainPciRombarMode {
+enum virDomainPCIRombarMode {
VIR_DOMAIN_PCI_ROMBAR_DEFAULT = 0,
VIR_DOMAIN_PCI_ROMBAR_ON,
VIR_DOMAIN_PCI_ROMBAR_OFF,
} master;
/* rombar and romfile are only used for pci hostdev and network
* devices. */
- int rombar; /* enum virDomainPciRombarMode */
+ int rombar; /* enum virDomainPCIRombarMode */
char *romfile;
/* bootIndex is only used for disk, network interface, hostdev
* and redirdev devices */
VIR_DOMAIN_HOSTDEV_PCI_BACKEND_XEN, /* force legacy xen style, use pciback */
VIR_DOMAIN_HOSTDEV_PCI_BACKEND_TYPE_LAST
-} virDomainHostdevSubsysPciBackendType;
+} virDomainHostdevSubsysPCIBackendType;
-VIR_ENUM_DECL(virDomainHostdevSubsysPciBackend)
+VIR_ENUM_DECL(virDomainHostdevSubsysPCIBackend)
typedef struct _virDomainHostdevSubsys virDomainHostdevSubsys;
typedef virDomainHostdevSubsys *virDomainHostdevSubsysPtr;
} usb;
struct {
virDevicePCIAddress addr; /* host address */
- int backend; /* enum virDomainHostdevSubsysPciBackendType */
+ int backend; /* enum virDomainHostdevSubsysPCIBackendType */
} pci;
struct {
char *adapter;
int vectors; /* -1 == undef */
};
-typedef struct _virDomainPciControllerOpts virDomainPciControllerOpts;
-typedef virDomainPciControllerOpts *virDomainPciControllerOptsPtr;
-struct _virDomainPciControllerOpts {
+typedef struct _virDomainPCIControllerOpts virDomainPCIControllerOpts;
+typedef virDomainPCIControllerOpts *virDomainPCIControllerOptsPtr;
+struct _virDomainPCIControllerOpts {
bool pcihole64;
unsigned long pcihole64size;
};
unsigned int queues;
union {
virDomainVirtioSerialOpts vioserial;
- virDomainPciControllerOpts pciopts;
+ virDomainPCIControllerOpts pciopts;
} opts;
virDomainDeviceInfo info;
};
VIR_ENUM_DECL(virDomainHostdevMode)
VIR_ENUM_DECL(virDomainHostdevSubsys)
VIR_ENUM_DECL(virDomainHostdevCaps)
-VIR_ENUM_DECL(virDomainPciRombarMode)
+VIR_ENUM_DECL(virDomainPCIRombarMode)
VIR_ENUM_DECL(virDomainHub)
VIR_ENUM_DECL(virDomainRedirdevBus)
VIR_ENUM_DECL(virDomainInput)
}
static int
-virNodeDevCapPciDevIommuGroupParseXML(xmlXPathContextPtr ctxt,
+virNodeDevCapPCIDevIommuGroupParseXML(xmlXPathContextPtr ctxt,
xmlNodePtr iommuGroupNode,
union _virNodeDevCapData *data)
{
static int
-virNodeDevCapPciDevParseXML(xmlXPathContextPtr ctxt,
+virNodeDevCapPCIDevParseXML(xmlXPathContextPtr ctxt,
virNodeDeviceDefPtr def,
xmlNodePtr node,
union _virNodeDevCapData *data)
data->pci_dev.product_name = virXPathString("string(./product[1])", ctxt);
if ((iommuGroupNode = virXPathNode("./iommuGroup[1]", ctxt))) {
- if (virNodeDevCapPciDevIommuGroupParseXML(ctxt, iommuGroupNode,
+ if (virNodeDevCapPCIDevIommuGroupParseXML(ctxt, iommuGroupNode,
data) < 0) {
goto out;
}
ret = virNodeDevCapSystemParseXML(ctxt, def, node, &caps->data);
break;
case VIR_NODE_DEV_CAP_PCI_DEV:
- ret = virNodeDevCapPciDevParseXML(ctxt, def, node, &caps->data);
+ ret = virNodeDevCapPCIDevParseXML(ctxt, def, node, &caps->data);
break;
case VIR_NODE_DEV_CAP_USB_DEV:
ret = virNodeDevCapUSBDevParseXML(ctxt, def, node, &caps->data);
# conf/device_conf.h
-virDeviceAddressPciMultiTypeFromString;
-virDeviceAddressPciMultiTypeToString;
+virDeviceAddressPCIMultiTypeFromString;
+virDeviceAddressPCIMultiTypeToString;
virDevicePCIAddressEqual;
virDevicePCIAddressFormat;
virDevicePCIAddressIsValid;
virDomainHostdevInsert;
virDomainHostdevModeTypeToString;
virDomainHostdevRemove;
-virDomainHostdevSubsysPciBackendTypeToString;
+virDomainHostdevSubsysPCIBackendTypeToString;
virDomainHostdevSubsysTypeToString;
virDomainHubTypeFromString;
virDomainHubTypeToString;
virDomainObjTaint;
virDomainPausedReasonTypeFromString;
virDomainPausedReasonTypeToString;
-virDomainPciRombarModeTypeFromString;
-virDomainPciRombarModeTypeToString;
+virDomainPCIRombarModeTypeFromString;
+virDomainPCIRombarModeTypeToString;
virDomainPMStateTypeFromString;
virDomainPMStateTypeToString;
virDomainPMSuspendedReasonTypeFromString;
}
int
-libxlMakePci(virDomainHostdevDefPtr hostdev, libxl_device_pci *pcidev)
+libxlMakePCI(virDomainHostdevDefPtr hostdev, libxl_device_pci *pcidev)
{
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
return -1;
}
static int
-libxlMakePciList(virDomainDefPtr def, libxl_domain_config *d_config)
+libxlMakePCIList(virDomainDefPtr def, libxl_domain_config *d_config)
{
virDomainHostdevDefPtr *l_hostdevs = def->hostdevs;
size_t nhostdevs = def->nhostdevs;
libxl_device_pci_init(&x_pcidevs[j]);
- if (libxlMakePci(l_hostdevs[i], &x_pcidevs[j]) < 0)
+ if (libxlMakePCI(l_hostdevs[i], &x_pcidevs[j]) < 0)
goto error;
npcidevs++;
if (libxlMakeVfbList(driver, def, d_config) < 0)
return -1;
- if (libxlMakePciList(def, d_config) < 0)
+ if (libxlMakePCIList(def, d_config) < 0)
return -1;
d_config->on_reboot = def->onReboot;
virDomainGraphicsDefPtr l_vfb, libxl_device_vfb *x_vfb);
int
-libxlMakePci(virDomainHostdevDefPtr hostdev, libxl_device_pci *pcidev);
+libxlMakePCI(virDomainHostdevDefPtr hostdev, libxl_device_pci *pcidev);
int
libxlBuildDomainConfig(libxlDriverPrivatePtr driver,
&hostdev, 1, 0) < 0)
return -1;
- if (libxlMakePci(hostdev, &pcidev) < 0)
+ if (libxlMakePCI(hostdev, &pcidev) < 0)
goto error;
if (libxl_device_pci_add(priv->ctx, vm->def->id, &pcidev, 0) < 0) {
libxl_device_pci_init(&pcidev);
- if (libxlMakePci(detach, &pcidev) < 0)
+ if (libxlMakePCI(detach, &pcidev) < 0)
goto error;
if (libxl_device_pci_remove(priv->ctx, vm->def->id, &pcidev, 0) < 0) {
} else if (netdef->forward.type == VIR_NETWORK_FORWARD_HOSTDEV) {
- virDomainHostdevSubsysPciBackendType backend;
+ virDomainHostdevSubsysPCIBackendType backend;
iface->data.network.actual->type = actualType = VIR_DOMAIN_NET_TYPE_HOSTDEV;
if (netdef->forward.npfs > 0 && netdef->forward.nifs <= 0 &&
{ "event_idx", QEMU_CAPS_VIRTIO_NET_EVENT_IDX },
};
-static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsPciAssign[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsPCIAssign[] = {
{ "rombar", QEMU_CAPS_PCI_ROMBAR },
{ "configfd", QEMU_CAPS_PCI_CONFIGFD },
{ "bootindex", QEMU_CAPS_PCI_BOOTINDEX },
};
-static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVfioPci[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVfioPCI[] = {
{ "bootindex", QEMU_CAPS_VFIO_PCI_BOOTINDEX },
};
{ "bootindex", QEMU_CAPS_DEVICE_SCSI_GENERIC_BOOTINDEX },
};
-static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsI440FXPciHost[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsI440FXPCIHost[] = {
{ "pci-hole64-size", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE },
};
-static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsQ35PciHost[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsQ35PCIHost[] = {
{ "pci-hole64-size", QEMU_CAPS_Q35_PCI_HOLE64_SIZE },
};
ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBlk) },
{ "virtio-net-s390", virQEMUCapsObjectPropsVirtioNet,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioNet) },
- { "pci-assign", virQEMUCapsObjectPropsPciAssign,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsPciAssign) },
- { "kvm-pci-assign", virQEMUCapsObjectPropsPciAssign,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsPciAssign) },
- { "vfio-pci", virQEMUCapsObjectPropsVfioPci,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsVfioPci) },
+ { "pci-assign", virQEMUCapsObjectPropsPCIAssign,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsPCIAssign) },
+ { "kvm-pci-assign", virQEMUCapsObjectPropsPCIAssign,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsPCIAssign) },
+ { "vfio-pci", virQEMUCapsObjectPropsVfioPCI,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsVfioPCI) },
{ "scsi-disk", virQEMUCapsObjectPropsSCSIDisk,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsSCSIDisk) },
{ "ide-drive", virQEMUCapsObjectPropsIDEDrive,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsUSBHost) },
{ "scsi-generic", virQEMUCapsObjectPropsSCSIGeneric,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsSCSIGeneric) },
- { "i440FX-pcihost", virQEMUCapsObjectPropsI440FXPciHost,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsI440FXPciHost) },
- { "q35-pcihost", virQEMUCapsObjectPropsQ35PciHost,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsQ35PciHost) },
+ { "i440FX-pcihost", virQEMUCapsObjectPropsI440FXPCIHost,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsI440FXPCIHost) },
+ { "q35-pcihost", virQEMUCapsObjectPropsQ35PCIHost,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsQ35PCIHost) },
{ "usb-storage", virQEMUCapsObjectPropsUSBStorage,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsUSBStorage) },
{ "kvm-pit", virQEMUCapsObjectPropsKVMPit,
int backend = dev->source.subsys.u.pci.backend;
/* caller has to assign proper passthrough backend type */
- switch ((virDomainHostdevSubsysPciBackendType) backend) {
+ switch ((virDomainHostdevSubsysPCIBackendType) backend) {
case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_KVM:
virBufferAddLit(&buf, "pci-assign");
if (configfd && *configfd)
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("invalid PCI passthrough type '%s'"),
- virDomainHostdevSubsysPciBackendTypeToString(backend));
+ virDomainHostdevSubsysPCIBackendTypeToString(backend));
break;
}
if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
continue;
- switch ((virDomainHostdevSubsysPciBackendType) *backend) {
+ switch ((virDomainHostdevSubsysPCIBackendType) *backend) {
case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT:
if (supportsPassthroughVFIO &&
virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_PCI)) {
/* this could have been changed by qemuPrepareHostdevPCIDevices */
backend = hostdev->source.subsys.u.pci.backend;
- switch ((virDomainHostdevSubsysPciBackendType) backend) {
+ switch ((virDomainHostdevSubsysPCIBackendType) backend) {
case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO:
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE_VFIO_PCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
static int
-qemuMonitorTextParsePciAddReply(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
+qemuMonitorTextParsePCIAddReply(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
const char *reply,
virDevicePCIAddress *addr)
{
goto cleanup;
}
- if (qemuMonitorTextParsePciAddReply(mon, reply, guestAddr) < 0) {
+ if (qemuMonitorTextParsePCIAddReply(mon, reply, guestAddr) < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("parsing pci_add reply failed: %s"), reply);
goto cleanup;
if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
goto cleanup;
- if (qemuMonitorTextParsePciAddReply(mon, reply, guestAddr) < 0) {
+ if (qemuMonitorTextParsePCIAddReply(mon, reply, guestAddr) < 0) {
if (!tryOldSyntax && strstr(reply, "invalid char in expression")) {
VIR_FREE(reply);
VIR_FREE(cmd);
if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
goto cleanup;
- if (qemuMonitorTextParsePciAddReply(mon, reply, guestAddr) < 0) {
+ if (qemuMonitorTextParsePCIAddReply(mon, reply, guestAddr) < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("parsing pci_add reply failed: %s"), reply);
goto cleanup;
if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
goto cleanup;
- if (qemuMonitorTextParsePciAddReply(mon, reply, guestAddr) < 0) {
+ if (qemuMonitorTextParsePCIAddReply(mon, reply, guestAddr) < 0) {
if (!tryOldSyntax && strstr(reply, "invalid char in expression")) {
VIR_FREE(reply);
VIR_FREE(cmd);
dev->source.subsys.u.pci.addr.slot,
dev->source.subsys.u.pci.addr.function);
- virDomainHostdevSubsysPciBackendType backend = dev->source.subsys.u.pci.backend;
+ virDomainHostdevSubsysPCIBackendType backend = dev->source.subsys.u.pci.backend;
if (backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO ||
backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT) {
needsVfio = true;
}
/* @oldStateDir
- * For upgrade purpose: see virHostdevReAttachPciHostdevs
+ * For upgrade purpose: see virHostdevReAttachPCIHostdevs
*/
void
virHostdevReAttachDomainDevices(virHostdevManagerPtr mgr,
static int
-xenUnifiedNodeDeviceGetPciInfo(virNodeDevicePtr dev,
+xenUnifiedNodeDeviceGetPCIInfo(virNodeDevicePtr dev,
unsigned *domain,
unsigned *bus,
unsigned *slot,
virCheckFlags(0, -1);
- if (xenUnifiedNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
+ if (xenUnifiedNodeDeviceGetPCIInfo(dev, &domain, &bus, &slot, &function) < 0)
return -1;
pci = virPCIDeviceNew(domain, bus, slot, function);
}
/* Get pci bdf */
- if (xenUnifiedNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
+ if (xenUnifiedNodeDeviceGetPCIInfo(dev, &domain, &bus, &slot, &function) < 0)
goto out;
if (virAsprintf(&bdf, "%04x:%02x:%02x.%0x",
int ret = -1;
int domid;
- if (xenUnifiedNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
+ if (xenUnifiedNodeDeviceGetPCIInfo(dev, &domain, &bus, &slot, &function) < 0)
return -1;
pci = virPCIDeviceNew(domain, bus, slot, function);
unsigned domain, bus, slot, function;
int ret = -1;
- if (xenUnifiedNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
+ if (xenUnifiedNodeDeviceGetPCIInfo(dev, &domain, &bus, &slot, &function) < 0)
return -1;
pci = virPCIDeviceNew(domain, bus, slot, function);
};
struct pciDevice **pciDevices = NULL;
-size_t nPciDevices = 0;
+size_t nPCIDevices = 0;
struct pciDriver **pciDrivers = NULL;
-size_t nPciDrivers = 0;
+size_t nPCIDrivers = 0;
struct fdCallback *callbacks = NULL;
size_t nCallbacks = 0;
if (pci_device_autobind(dev) < 0)
ABORT("Unable to bind: %s", data->id);
- if (VIR_APPEND_ELEMENT_QUIET(pciDevices, nPciDevices, dev) < 0)
+ if (VIR_APPEND_ELEMENT_QUIET(pciDevices, nPCIDevices, dev) < 0)
ABORT_OOM();
VIR_FREE(devpath);
pci_device_find_by_id(const char *id)
{
size_t i;
- for (i = 0; i < nPciDevices; i++) {
+ for (i = 0; i < nPCIDevices; i++) {
struct pciDevice *dev = pciDevices[i];
if (STREQ(dev->id, id))
make_file(driverpath, "new_id", NULL, -1);
make_file(driverpath, "remove_id", NULL, -1);
- if (VIR_APPEND_ELEMENT_QUIET(pciDrivers, nPciDrivers, driver) < 0)
+ if (VIR_APPEND_ELEMENT_QUIET(pciDrivers, nPCIDrivers, driver) < 0)
ABORT_OOM();
}
{
size_t i;
- for (i = 0; i < nPciDrivers; i++) {
+ for (i = 0; i < nPCIDrivers; i++) {
struct pciDriver *driver = pciDrivers[i];
size_t j;
{
size_t i;
- for (i = 0; i < nPciDrivers; i++) {
+ for (i = 0; i < nPCIDrivers; i++) {
struct pciDriver *driver = pciDrivers[i];
if (strstr(path, driver->name))
driver->len++;
}
- for (i = 0; i < nPciDevices; i++) {
+ for (i = 0; i < nPCIDevices; i++) {
struct pciDevice *dev = pciDevices[i];
if (!dev->driver &&