}
static int
-virDomainHostdevSubsysUsbDefParseXML(xmlNodePtr node,
+virDomainHostdevSubsysUSBDefParseXML(xmlNodePtr node,
virDomainHostdevDefPtr def)
{
break;
case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
- if (virDomainHostdevSubsysUsbDefParseXML(sourcenode, def) < 0)
+ if (virDomainHostdevSubsysUSBDefParseXML(sourcenode, def) < 0)
goto error;
break;
* USB 1.1 as 0x0110 and USB 1.0 as 0x0100.
*/
static int
-virDomainRedirFilterUsbVersionHelper(const char *version,
- virDomainRedirFilterUsbDevDefPtr def)
+virDomainRedirFilterUSBVersionHelper(const char *version,
+ virDomainRedirFilterUSBDevDefPtr def)
{
char *version_copy = NULL;
char *temp = NULL;
return ret;
}
-static virDomainRedirFilterUsbDevDefPtr
-virDomainRedirFilterUsbDevDefParseXML(xmlNodePtr node)
+static virDomainRedirFilterUSBDevDefPtr
+virDomainRedirFilterUSBDevDefParseXML(xmlNodePtr node)
{
char *class;
char *vendor = NULL, *product = NULL;
char *version = NULL, *allow = NULL;
- virDomainRedirFilterUsbDevDefPtr def;
+ virDomainRedirFilterUSBDevDefPtr def;
if (VIR_ALLOC(def) < 0)
return NULL;
if (version) {
if (STREQ(version, "-1"))
def->version = -1;
- else if ((virDomainRedirFilterUsbVersionHelper(version, def)) < 0)
+ else if ((virDomainRedirFilterUSBVersionHelper(version, def)) < 0)
goto error;
} else {
def->version = -1;
goto error;
for (i = 0; i < n; i++) {
- virDomainRedirFilterUsbDevDefPtr usbdev =
- virDomainRedirFilterUsbDevDefParseXML(nodes[i]);
+ virDomainRedirFilterUSBDevDefPtr usbdev =
+ virDomainRedirFilterUSBDevDefParseXML(nodes[i]);
if (!usbdev)
goto error;
}
for (i = 0; i < src->nusbdevs; i++) {
- virDomainRedirFilterUsbDevDefPtr srcUsbDev = src->usbdevs[i];
- virDomainRedirFilterUsbDevDefPtr dstUsbDev = dst->usbdevs[i];
- if (srcUsbDev->usbClass != dstUsbDev->usbClass) {
+ virDomainRedirFilterUSBDevDefPtr srcUSBDev = src->usbdevs[i];
+ virDomainRedirFilterUSBDevDefPtr dstUSBDev = dst->usbdevs[i];
+ if (srcUSBDev->usbClass != dstUSBDev->usbClass) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("Target USB Class code does not match source"));
return false;
}
- if (srcUsbDev->vendor != dstUsbDev->vendor) {
+ if (srcUSBDev->vendor != dstUSBDev->vendor) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("Target USB vendor ID does not match source"));
return false;
}
- if (srcUsbDev->product != dstUsbDev->product) {
+ if (srcUSBDev->product != dstUSBDev->product) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("Target USB product ID does not match source"));
return false;
}
- if (srcUsbDev->version != dstUsbDev->version) {
+ if (srcUSBDev->version != dstUSBDev->version) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("Target USB version does not match source"));
return false;
}
- if (srcUsbDev->allow != dstUsbDev->allow) {
+ if (srcUSBDev->allow != dstUSBDev->allow) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Target USB allow '%s' does not match source '%s'"),
- dstUsbDev->allow ? "yes" : "no",
- srcUsbDev->allow ? "yes" : "no");
+ dstUSBDev->allow ? "yes" : "no",
+ srcUSBDev->allow ? "yes" : "no");
return false;
}
}
virBufferAddLit(buf, "<redirfilter>\n");
virBufferAdjustIndent(buf, 2);
for (i = 0; i < filter->nusbdevs; i++) {
- virDomainRedirFilterUsbDevDefPtr usbdev = filter->usbdevs[i];
+ virDomainRedirFilterUSBDevDefPtr usbdev = filter->usbdevs[i];
virBufferAddLit(buf, "<usbdev");
if (usbdev->usbClass >= 0)
virBufferAsprintf(buf, " class='0x%02X'", usbdev->usbClass);
typedef struct _virDomainRedirdevDef virDomainRedirdevDef;
typedef virDomainRedirdevDef *virDomainRedirdevDefPtr;
-typedef struct _virDomainRedirFilterUsbDevDef virDomainRedirFilterUsbDevDef;
-typedef virDomainRedirFilterUsbDevDef *virDomainRedirFilterUsbDevDefPtr;
+typedef struct _virDomainRedirFilterUSBDevDef virDomainRedirFilterUSBDevDef;
+typedef virDomainRedirFilterUSBDevDef *virDomainRedirFilterUSBDevDefPtr;
typedef struct _virDomainRedirFilterDef virDomainRedirFilterDef;
typedef virDomainRedirFilterDef *virDomainRedirFilterDefPtr;
virDomainDeviceInfo info; /* Guest address */
};
-struct _virDomainRedirFilterUsbDevDef {
+struct _virDomainRedirFilterUSBDevDef {
int usbClass;
int vendor;
int product;
struct _virDomainRedirFilterDef {
size_t nusbdevs;
- virDomainRedirFilterUsbDevDefPtr *usbdevs;
+ virDomainRedirFilterUSBDevDefPtr *usbdevs;
};
enum virDomainMemDump {
}
static int
-virNodeDevCapUsbInterfaceParseXML(xmlXPathContextPtr ctxt,
+virNodeDevCapUSBInterfaceParseXML(xmlXPathContextPtr ctxt,
virNodeDeviceDefPtr def,
xmlNodePtr node,
union _virNodeDevCapData *data)
}
static int
-virNodeDevCapUsbDevParseXML(xmlXPathContextPtr ctxt,
+virNodeDevCapUSBDevParseXML(xmlXPathContextPtr ctxt,
virNodeDeviceDefPtr def,
xmlNodePtr node,
union _virNodeDevCapData *data)
ret = virNodeDevCapPciDevParseXML(ctxt, def, node, &caps->data);
break;
case VIR_NODE_DEV_CAP_USB_DEV:
- ret = virNodeDevCapUsbDevParseXML(ctxt, def, node, &caps->data);
+ ret = virNodeDevCapUSBDevParseXML(ctxt, def, node, &caps->data);
break;
case VIR_NODE_DEV_CAP_USB_INTERFACE:
- ret = virNodeDevCapUsbInterfaceParseXML(ctxt, def, node, &caps->data);
+ ret = virNodeDevCapUSBInterfaceParseXML(ctxt, def, node, &caps->data);
break;
case VIR_NODE_DEV_CAP_NET:
ret = virNodeDevCapNetParseXML(ctxt, def, node, &caps->data);
int
-virLXCSetupHostUsbDeviceCgroup(virUSBDevicePtr dev ATTRIBUTE_UNUSED,
+virLXCSetupHostUSBDeviceCgroup(virUSBDevicePtr dev ATTRIBUTE_UNUSED,
const char *path,
void *opaque)
{
int
-virLXCTeardownHostUsbDeviceCgroup(virUSBDevicePtr dev ATTRIBUTE_UNUSED,
+virLXCTeardownHostUSBDeviceCgroup(virUSBDevicePtr dev ATTRIBUTE_UNUSED,
const char *path,
void *opaque)
{
NULL)) == NULL)
goto cleanup;
- if (virUSBDeviceFileIterate(usb, virLXCSetupHostUsbDeviceCgroup,
+ if (virUSBDeviceFileIterate(usb, virLXCSetupHostUSBDeviceCgroup,
cgroup) < 0) {
virUSBDeviceFree(usb);
goto cleanup;
int virLXCCgroupGetMeminfo(virLXCMeminfoPtr meminfo);
int
-virLXCSetupHostUsbDeviceCgroup(virUSBDevicePtr dev,
+virLXCSetupHostUSBDeviceCgroup(virUSBDevicePtr dev,
const char *path,
void *opaque);
int
-virLXCTeardownHostUsbDeviceCgroup(virUSBDevicePtr dev,
+virLXCTeardownHostUSBDeviceCgroup(virUSBDevicePtr dev,
const char *path,
void *opaque);
goto cleanup;
if (virUSBDeviceFileIterate(usb,
- virLXCSetupHostUsbDeviceCgroup,
+ virLXCSetupHostUSBDeviceCgroup,
priv->cgroup) < 0)
goto cleanup;
dev,
src) < 0) {
if (virUSBDeviceFileIterate(usb,
- virLXCTeardownHostUsbDeviceCgroup,
+ virLXCTeardownHostUSBDeviceCgroup,
priv->cgroup) < 0)
VIR_WARN("cannot deny device %s for domain %s",
src, vm->def->name);
virDomainAuditHostdev(vm, def, "detach", true);
if (virUSBDeviceFileIterate(usb,
- virLXCTeardownHostUsbDeviceCgroup,
+ virLXCTeardownHostUSBDeviceCgroup,
priv->cgroup) < 0)
VIR_WARN("cannot deny device %s for domain %s",
dst, vm->def->name);
VIR_LOG_INIT("lxc.lxc_hostdev");
int
-virLXCUpdateActiveUsbHostdevs(virLXCDriverPtr driver,
+virLXCUpdateActiveUSBHostdevs(virLXCDriverPtr driver,
virDomainDefPtr def)
{
virHostdevManagerPtr hostdev_mgr = driver->hostdevMgr;
static void
-virLXCDomainReAttachHostUsbDevices(virLXCDriverPtr driver,
+virLXCDomainReAttachHostUSBDevices(virLXCDriverPtr driver,
const char *name,
virDomainHostdevDefPtr *hostdevs,
int nhostdevs)
if (!def->nhostdevs)
return;
- virLXCDomainReAttachHostUsbDevices(driver, def->name, def->hostdevs,
+ virLXCDomainReAttachHostUSBDevices(driver, def->name, def->hostdevs,
def->nhostdevs);
}
# include "lxc_conf.h"
# include "domain_conf.h"
-int virLXCUpdateActiveUsbHostdevs(virLXCDriverPtr driver,
+int virLXCUpdateActiveUSBHostdevs(virLXCDriverPtr driver,
virDomainDefPtr def);
int virLXCFindHostdevUSBDevice(virDomainHostdevDefPtr hostdev,
bool mandatory,
goto error;
}
- if (virLXCUpdateActiveUsbHostdevs(driver, vm->def) < 0)
+ if (virLXCUpdateActiveUSBHostdevs(driver, vm->def) < 0)
goto error;
if (virSecurityManagerReserveLabel(driver->securityManager,
{ "disable_s4", QEMU_CAPS_DISABLE_S4 },
};
-static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUsbRedir[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUSBRedir[] = {
{ "filter", QEMU_CAPS_USB_REDIR_FILTER },
{ "bootindex", QEMU_CAPS_USB_REDIR_BOOTINDEX },
};
-static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUsbHost[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUSBHost[] = {
{ "bootindex", QEMU_CAPS_USB_HOST_BOOTINDEX },
};
{ "pci-hole64-size", QEMU_CAPS_Q35_PCI_HOLE64_SIZE },
};
-static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUsbStorage[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUSBStorage[] = {
{ "removable", QEMU_CAPS_USB_STORAGE_REMOVABLE },
};
ARRAY_CARDINALITY(virQEMUCapsObjectPropsIDEDrive) },
{ "PIIX4_PM", virQEMUCapsObjectPropsPixx4PM,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsPixx4PM) },
- { "usb-redir", virQEMUCapsObjectPropsUsbRedir,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsUsbRedir) },
- { "usb-host", virQEMUCapsObjectPropsUsbHost,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsUsbHost) },
+ { "usb-redir", virQEMUCapsObjectPropsUSBRedir,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsUSBRedir) },
+ { "usb-host", virQEMUCapsObjectPropsUSBHost,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsUSBHost) },
{ "scsi-generic", virQEMUCapsObjectPropsSCSIGeneric,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsSCSIGeneric) },
{ "i440FX-pcihost", virQEMUCapsObjectPropsI440FXPciHost,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsI440FXPciHost) },
{ "q35-pcihost", virQEMUCapsObjectPropsQ35PciHost,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsQ35PciHost) },
- { "usb-storage", virQEMUCapsObjectPropsUsbStorage,
- ARRAY_CARDINALITY(virQEMUCapsObjectPropsUsbStorage) },
+ { "usb-storage", virQEMUCapsObjectPropsUSBStorage,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsUSBStorage) },
{ "kvm-pit", virQEMUCapsObjectPropsKVMPit,
ARRAY_CARDINALITY(virQEMUCapsObjectPropsKVMPit) },
};
static int
-qemuSetupHostUsbDeviceCgroup(virUSBDevicePtr dev ATTRIBUTE_UNUSED,
+qemuSetupHostUSBDeviceCgroup(virUSBDevicePtr dev ATTRIBUTE_UNUSED,
const char *path,
void *opaque)
{
goto cleanup;
}
- /* oddly, qemuSetupHostUsbDeviceCgroup doesn't ever
+ /* oddly, qemuSetupHostUSBDeviceCgroup doesn't ever
* reference the usb object we just created
*/
- if (virUSBDeviceFileIterate(usb, qemuSetupHostUsbDeviceCgroup,
+ if (virUSBDeviceFileIterate(usb, qemuSetupHostUSBDeviceCgroup,
vm) < 0) {
goto cleanup;
}
}
static void
-qemuUsbId(virBufferPtr buf, int idx)
+qemuUSBId(virBufferPtr buf, int idx)
{
if (idx == 0)
virBufferAddLit(buf, "usb");
virBufferAsprintf(buf, ".0x%x", info->addr.pci.function);
} else if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB) {
virBufferAddLit(buf, ",bus=");
- qemuUsbId(buf, info->addr.usb.bus);
+ qemuUSBId(buf, info->addr.usb.bus);
virBufferAsprintf(buf, ".0,port=%s", info->addr.usb.port);
} else if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO) {
if (info->addr.spaprvio.has_reg)
if (def->info.mastertype == VIR_DOMAIN_CONTROLLER_MASTER_USB) {
virBufferAddLit(buf, ",masterbus=");
- qemuUsbId(buf, def->idx);
+ qemuUSBId(buf, def->idx);
virBufferAsprintf(buf, ".0,firstport=%d", def->info.master.usb.startport);
} else {
virBufferAddLit(buf, ",id=");
- qemuUsbId(buf, def->idx);
+ qemuUSBId(buf, def->idx);
}
return 0;
virBufferAddLit(&buf, ",filter=");
for (i = 0; i < redirfilter->nusbdevs; i++) {
- virDomainRedirFilterUsbDevDefPtr usbdev = redirfilter->usbdevs[i];
+ virDomainRedirFilterUSBDevDefPtr usbdev = redirfilter->usbdevs[i];
if (usbdev->usbClass >= 0)
virBufferAsprintf(&buf, "0x%02X:", usbdev->usbClass);
else
char *
-qemuBuildUSBHostdevUsbDevStr(virDomainHostdevDefPtr dev)
+qemuBuildUSBHostdevUSBDevStr(virDomainHostdevDefPtr dev)
{
char *ret = NULL;
VIR_FREE(devstr);
} else {
virCommandAddArg(cmd, "-usbdevice");
- if (!(devstr = qemuBuildUSBHostdevUsbDevStr(hostdev)))
+ if (!(devstr = qemuBuildUSBHostdevUSBDevStr(hostdev)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
int qemuOpenPCIConfig(virDomainHostdevDefPtr dev);
/* Legacy, pre device support */
-char * qemuBuildUSBHostdevUsbDevStr(virDomainHostdevDefPtr dev);
+char * qemuBuildUSBHostdevUSBDevStr(virDomainHostdevDefPtr dev);
/* Current, best practice */
char * qemuBuildUSBHostdevDevStr(virDomainDefPtr def,
virDomainHostdevDefPtr dev,