From: "Daniel P. Berrange" <berrange@xxxxxxxxxx>
The current qemu capabilities are stored in a virBitmapPtr
object, whose type is exposed to callers. We want to store
more data besides just the flags, so we need to move to a
struct type. This object will also need to be reference
counted, since we'll be maintaining a cache of data per
binary. This change introduces a 'qemuCapsPtr' virObject
class. Most of the change is just renaming types and
variables in all the callers
Signed-off-by: Daniel P. Berrange <berrange@xxxxxxxxxx>
---
src/qemu/qemu_capabilities.c | 376 ++++++++++++++++------------
src/qemu/qemu_capabilities.h | 29 ++-
src/qemu/qemu_command.c | 580 +++++++++++++++++++++----------------------
src/qemu/qemu_command.h | 53 ++--
src/qemu/qemu_domain.c | 16 +-
src/qemu/qemu_domain.h | 4 +-
src/qemu/qemu_driver.c | 40 +--
src/qemu/qemu_hotplug.c | 138 +++++-----
src/qemu/qemu_migration.c | 16 +-
src/qemu/qemu_monitor.c | 6 +-
src/qemu/qemu_monitor.h | 3 +-
src/qemu/qemu_monitor_json.c | 16 +-
src/qemu/qemu_monitor_json.h | 4 +-
src/qemu/qemu_process.c | 62 ++---
tests/qemuhelptest.c | 16 +-
tests/qemuxml2argvtest.c | 6 +-
tests/qemuxmlnstest.c | 6 +-
17 files changed, 712 insertions(+), 659 deletions(-)
diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c
index ed85b6f..b8c1f36 100644
--- a/src/qemu/qemu_capabilities.c
+++ b/src/qemu/qemu_capabilities.c
@@ -178,6 +178,28 @@ VIR_ENUM_IMPL(qemuCaps, QEMU_CAPS_LAST,
"disable-s4", /* 105 */
);
+struct _qemuCaps {
+ virObject object;
+
+ virBitmapPtr flags;
+};
+
+
+static virClassPtr qemuCapsClass;
+static void qemuCapsDispose(void *obj);
+
+static int qemuCapsOnceInit(void)
+{
+ if (!(qemuCapsClass = virClassNew("qemuCaps",
+ sizeof(qemuCaps),
+ qemuCapsDispose)))
+ return -1;
+
+ return 0;
+}
+
+VIR_ONCE_GLOBAL_INIT(qemuCaps)
+
struct qemu_feature_flags {
const char *name;
const int default_on;
@@ -304,7 +326,7 @@ qemuCapsParseMachineTypesStr(const char *output,
int
qemuCapsProbeMachineTypes(const char *binary,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virCapsGuestMachinePtr **machines,
int *nmachines)
{
@@ -322,7 +344,7 @@ qemuCapsProbeMachineTypes(const char *binary,
return -1;
}
- cmd = qemuCapsProbeCommand(binary, qemuCaps);
+ cmd = qemuCapsProbeCommand(binary, caps);
virCommandAddArgList(cmd, "-M", "?", NULL);
virCommandSetOutputBuffer(cmd, &output);
@@ -590,7 +612,7 @@ cleanup:
int
qemuCapsProbeCPUModels(const char *qemu,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const char *arch,
unsigned int *count,
const char ***cpus)
@@ -614,7 +636,7 @@ qemuCapsProbeCPUModels(const char *qemu,
return 0;
}
- cmd = qemuCapsProbeCommand(qemu, qemuCaps);
+ cmd = qemuCapsProbeCommand(qemu, caps);
virCommandAddArgList(cmd, "-cpu", "?", NULL);
virCommandSetOutputBuffer(cmd, &output);
@@ -652,8 +674,8 @@ qemuCapsInitGuest(virCapsPtr caps,
int nmachines = 0;
struct stat st;
unsigned int ncpus;
- virBitmapPtr qemuCaps = NULL;
- virBitmapPtr kvmCaps = NULL;
+ qemuCapsPtr qemubinCaps = NULL;
+ qemuCapsPtr kvmbinCaps = NULL;
int ret = -1;
/* Check for existance of base emulator, or alternate base
@@ -669,7 +691,7 @@ qemuCapsInitGuest(virCapsPtr caps,
/* Ignore binary if extracting version info fails */
if (binary &&
qemuCapsExtractVersionInfo(binary, info->arch,
- false, NULL, &qemuCaps) < 0)
+ false, NULL, &qemubinCaps) < 0)
VIR_FREE(binary);
/* qemu-kvm/kvm binaries can only be used if
@@ -692,16 +714,16 @@ qemuCapsInitGuest(virCapsPtr caps,
if (qemuCapsExtractVersionInfo(kvmbin, info->arch,
false, NULL,
- &kvmCaps) < 0) {
+ &kvmbinCaps) < 0) {
VIR_FREE(kvmbin);
continue;
}
if (!binary) {
binary = kvmbin;
- qemuCaps = kvmCaps;
+ qemubinCaps = kvmbinCaps;
kvmbin = NULL;
- kvmCaps = NULL;
+ kvmbinCaps = NULL;
}
break;
}
@@ -711,13 +733,13 @@ qemuCapsInitGuest(virCapsPtr caps,
return 0;
if (access("/dev/kvm", F_OK) == 0 &&
- (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM) ||
- qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KVM) ||
+ (qemuCapsGet(qemubinCaps, QEMU_CAPS_KVM) ||
+ qemuCapsGet(qemubinCaps, QEMU_CAPS_ENABLE_KVM) ||
kvmbin))
haskvm = 1;
if (access("/dev/kqemu", F_OK) == 0 &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
+ qemuCapsGet(qemubinCaps, QEMU_CAPS_KQEMU))
haskqemu = 1;
if (stat(binary, &st) == 0) {
@@ -757,7 +779,7 @@ qemuCapsInitGuest(virCapsPtr caps,
info->wordsize, binary, binary_mtime,
old_caps, &machines, &nmachines);
if (probe &&
- qemuCapsProbeMachineTypes(binary, qemuCaps,
+ qemuCapsProbeMachineTypes(binary, qemubinCaps,
&machines, &nmachines) < 0)
goto error;
}
@@ -785,7 +807,7 @@ qemuCapsInitGuest(virCapsPtr caps,
!virCapabilitiesAddGuestFeature(guest, "cpuselection", 1, 0))
goto error;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX) &&
+ if (qemuCapsGet(qemubinCaps, QEMU_CAPS_BOOTINDEX) &&
!virCapabilitiesAddGuestFeature(guest, "deviceboot", 1, 0))
goto error;
@@ -828,7 +850,7 @@ qemuCapsInitGuest(virCapsPtr caps,
binary_mtime, old_caps,
&machines, &nmachines);
if (probe &&
- qemuCapsProbeMachineTypes(kvmbin, qemuCaps,
+ qemuCapsProbeMachineTypes(kvmbin, kvmbinCaps,
&machines, &nmachines) < 0)
goto error;
}
@@ -872,8 +894,8 @@ qemuCapsInitGuest(virCapsPtr caps,
cleanup:
VIR_FREE(binary);
VIR_FREE(kvmbin);
- qemuCapsFree(qemuCaps);
- qemuCapsFree(kvmCaps);
+ virObjectUnref(qemubinCaps);
+ virObjectUnref(kvmbinCaps);
return ret;
@@ -1023,122 +1045,122 @@ qemuCapsComputeCmdFlags(const char *help,
unsigned int version,
unsigned int is_kvm,
unsigned int kvm_version,
- virBitmapPtr flags,
+ qemuCapsPtr caps,
bool check_yajl ATTRIBUTE_UNUSED)
{
const char *p;
const char *fsdev, *netdev;
if (strstr(help, "-no-kqemu"))
- qemuCapsSet(flags, QEMU_CAPS_KQEMU);
+ qemuCapsSet(caps, QEMU_CAPS_KQEMU);
if (strstr(help, "-enable-kqemu"))
- qemuCapsSet(flags, QEMU_CAPS_ENABLE_KQEMU);
+ qemuCapsSet(caps, QEMU_CAPS_ENABLE_KQEMU);
if (strstr(help, "-no-kvm"))
- qemuCapsSet(flags, QEMU_CAPS_KVM);
+ qemuCapsSet(caps, QEMU_CAPS_KVM);
if (strstr(help, "-enable-kvm"))
- qemuCapsSet(flags, QEMU_CAPS_ENABLE_KVM);
+ qemuCapsSet(caps, QEMU_CAPS_ENABLE_KVM);
if (strstr(help, "-no-reboot"))
- qemuCapsSet(flags, QEMU_CAPS_NO_REBOOT);
+ qemuCapsSet(caps, QEMU_CAPS_NO_REBOOT);
if (strstr(help, "-name")) {
- qemuCapsSet(flags, QEMU_CAPS_NAME);
+ qemuCapsSet(caps, QEMU_CAPS_NAME);
if (strstr(help, ",process="))
- qemuCapsSet(flags, QEMU_CAPS_NAME_PROCESS);
+ qemuCapsSet(caps, QEMU_CAPS_NAME_PROCESS);
}
if (strstr(help, "-uuid"))
- qemuCapsSet(flags, QEMU_CAPS_UUID);
+ qemuCapsSet(caps, QEMU_CAPS_UUID);
if (strstr(help, "-xen-domid"))
- qemuCapsSet(flags, QEMU_CAPS_XEN_DOMID);
+ qemuCapsSet(caps, QEMU_CAPS_XEN_DOMID);
else if (strstr(help, "-domid"))
- qemuCapsSet(flags, QEMU_CAPS_DOMID);
+ qemuCapsSet(caps, QEMU_CAPS_DOMID);
if (strstr(help, "-drive")) {
const char *cache = strstr(help, "cache=");
- qemuCapsSet(flags, QEMU_CAPS_DRIVE);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE);
if (cache && (p = strchr(cache, ']'))) {
if (memmem(cache, p - cache, "on|off", sizeof("on|off") - 1) == NULL)
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_CACHE_V2);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_V2);
if (memmem(cache, p - cache, "directsync", sizeof("directsync") - 1))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
if (memmem(cache, p - cache, "unsafe", sizeof("unsafe") - 1))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
}
if (strstr(help, "format="))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_FORMAT);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_FORMAT);
if (strstr(help, "readonly="))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_READONLY);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_READONLY);
if (strstr(help, "aio=threads|native"))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_AIO);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_AIO);
if (strstr(help, "copy-on-read=on|off"))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_COPY_ON_READ);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_COPY_ON_READ);
if (strstr(help, "bps="))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_IOTUNE);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_IOTUNE);
}
if ((p = strstr(help, "-vga")) && !strstr(help, "-std-vga")) {
const char *nl = strstr(p, "\n");
- qemuCapsSet(flags, QEMU_CAPS_VGA);
+ qemuCapsSet(caps, QEMU_CAPS_VGA);
if (strstr(p, "|qxl"))
- qemuCapsSet(flags, QEMU_CAPS_VGA_QXL);
+ qemuCapsSet(caps, QEMU_CAPS_VGA_QXL);
if ((p = strstr(p, "|none")) && p < nl)
- qemuCapsSet(flags, QEMU_CAPS_VGA_NONE);
+ qemuCapsSet(caps, QEMU_CAPS_VGA_NONE);
}
if (strstr(help, "-spice"))
- qemuCapsSet(flags, QEMU_CAPS_SPICE);
+ qemuCapsSet(caps, QEMU_CAPS_SPICE);
if (strstr(help, "boot=on"))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_BOOT);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_BOOT);
if (strstr(help, "serial=s"))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_SERIAL);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_SERIAL);
if (strstr(help, "-pcidevice"))
- qemuCapsSet(flags, QEMU_CAPS_PCIDEVICE);
+ qemuCapsSet(caps, QEMU_CAPS_PCIDEVICE);
if (strstr(help, "-mem-path"))
- qemuCapsSet(flags, QEMU_CAPS_MEM_PATH);
+ qemuCapsSet(caps, QEMU_CAPS_MEM_PATH);
if (strstr(help, "-chardev")) {
- qemuCapsSet(flags, QEMU_CAPS_CHARDEV);
+ qemuCapsSet(caps, QEMU_CAPS_CHARDEV);
if (strstr(help, "-chardev spicevmc"))
- qemuCapsSet(flags, QEMU_CAPS_CHARDEV_SPICEVMC);
+ qemuCapsSet(caps, QEMU_CAPS_CHARDEV_SPICEVMC);
}
if (strstr(help, "-balloon"))
- qemuCapsSet(flags, QEMU_CAPS_BALLOON);
+ qemuCapsSet(caps, QEMU_CAPS_BALLOON);
if (strstr(help, "-device")) {
- qemuCapsSet(flags, QEMU_CAPS_DEVICE);
+ qemuCapsSet(caps, QEMU_CAPS_DEVICE);
/*
* When -device was introduced, qemu already supported drive's
* readonly option but didn't advertise that.
*/
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_READONLY);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_READONLY);
}
if (strstr(help, "-nodefconfig"))
- qemuCapsSet(flags, QEMU_CAPS_NODEFCONFIG);
+ qemuCapsSet(caps, QEMU_CAPS_NODEFCONFIG);
if (strstr(help, "-no-user-config"))
- qemuCapsSet(flags, QEMU_CAPS_NO_USER_CONFIG);
+ qemuCapsSet(caps, QEMU_CAPS_NO_USER_CONFIG);
/* The trailing ' ' is important to avoid a bogus match */
if (strstr(help, "-rtc "))
- qemuCapsSet(flags, QEMU_CAPS_RTC);
+ qemuCapsSet(caps, QEMU_CAPS_RTC);
/* to wit */
if (strstr(help, "-rtc-td-hack"))
- qemuCapsSet(flags, QEMU_CAPS_RTC_TD_HACK);
+ qemuCapsSet(caps, QEMU_CAPS_RTC_TD_HACK);
if (strstr(help, "-no-hpet"))
- qemuCapsSet(flags, QEMU_CAPS_NO_HPET);
+ qemuCapsSet(caps, QEMU_CAPS_NO_HPET);
if (strstr(help, "-no-acpi"))
- qemuCapsSet(flags, QEMU_CAPS_NO_ACPI);
+ qemuCapsSet(caps, QEMU_CAPS_NO_ACPI);
if (strstr(help, "-no-kvm-pit-reinjection"))
- qemuCapsSet(flags, QEMU_CAPS_NO_KVM_PIT);
+ qemuCapsSet(caps, QEMU_CAPS_NO_KVM_PIT);
if (strstr(help, "-tdf"))
- qemuCapsSet(flags, QEMU_CAPS_TDF);
+ qemuCapsSet(caps, QEMU_CAPS_TDF);
if (strstr(help, "-enable-nesting"))
- qemuCapsSet(flags, QEMU_CAPS_NESTING);
+ qemuCapsSet(caps, QEMU_CAPS_NESTING);
if (strstr(help, ",menu=on"))
- qemuCapsSet(flags, QEMU_CAPS_BOOT_MENU);
+ qemuCapsSet(caps, QEMU_CAPS_BOOT_MENU);
if ((fsdev = strstr(help, "-fsdev"))) {
- qemuCapsSet(flags, QEMU_CAPS_FSDEV);
+ qemuCapsSet(caps, QEMU_CAPS_FSDEV);
if (strstr(fsdev, "readonly"))
- qemuCapsSet(flags, QEMU_CAPS_FSDEV_READONLY);
+ qemuCapsSet(caps, QEMU_CAPS_FSDEV_READONLY);
if (strstr(fsdev, "writeout"))
- qemuCapsSet(flags, QEMU_CAPS_FSDEV_WRITEOUT);
+ qemuCapsSet(caps, QEMU_CAPS_FSDEV_WRITEOUT);
}
if (strstr(help, "-smbios type"))
- qemuCapsSet(flags, QEMU_CAPS_SMBIOS_TYPE);
+ qemuCapsSet(caps, QEMU_CAPS_SMBIOS_TYPE);
if ((netdev = strstr(help, "-netdev"))) {
/* Disable -netdev on 0.12 since although it exists,
@@ -1147,26 +1169,26 @@ qemuCapsComputeCmdFlags(const char *help,
* But see below about RHEL build. */
if (version >= 13000) {
if (strstr(netdev, "bridge"))
- qemuCapsSet(flags, QEMU_CAPS_NETDEV_BRIDGE);
- qemuCapsSet(flags, QEMU_CAPS_NETDEV);
+ qemuCapsSet(caps, QEMU_CAPS_NETDEV_BRIDGE);
+ qemuCapsSet(caps, QEMU_CAPS_NETDEV);
}
}
if (strstr(help, "-sdl"))
- qemuCapsSet(flags, QEMU_CAPS_SDL);
+ qemuCapsSet(caps, QEMU_CAPS_SDL);
if (strstr(help, "cores=") &&
strstr(help, "threads=") &&
strstr(help, "sockets="))
- qemuCapsSet(flags, QEMU_CAPS_SMP_TOPOLOGY);
+ qemuCapsSet(caps, QEMU_CAPS_SMP_TOPOLOGY);
if (version >= 9000)
- qemuCapsSet(flags, QEMU_CAPS_VNC_COLON);
+ qemuCapsSet(caps, QEMU_CAPS_VNC_COLON);
if (is_kvm && (version >= 10000 || kvm_version >= 74))
- qemuCapsSet(flags, QEMU_CAPS_VNET_HDR);
+ qemuCapsSet(caps, QEMU_CAPS_VNET_HDR);
if (strstr(help, ",vhost=")) {
- qemuCapsSet(flags, QEMU_CAPS_VHOST_NET);
+ qemuCapsSet(caps, QEMU_CAPS_VHOST_NET);
}
/* Do not use -no-shutdown if qemu doesn't support it or SIGTERM handling
@@ -1174,7 +1196,7 @@ qemuCapsComputeCmdFlags(const char *help,
* 0.14.* and 0.15.0)
*/
if (strstr(help, "-no-shutdown") && (version < 14000 || version > 15000))
- qemuCapsSet(flags, QEMU_CAPS_NO_SHUTDOWN);
+ qemuCapsSet(caps, QEMU_CAPS_NO_SHUTDOWN);
/*
* Handling of -incoming arg with varying features
@@ -1189,25 +1211,25 @@ qemuCapsComputeCmdFlags(const char *help,
* while waiting for data, so pretend it doesn't exist
*/
if (version >= 10000) {
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_TCP);
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_EXEC);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
if (version >= 12000) {
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_UNIX);
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_FD);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_UNIX);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_FD);
}
} else if (kvm_version >= 79) {
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_TCP);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP);
if (kvm_version >= 80)
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_EXEC);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
} else if (kvm_version > 0) {
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_KVM_STDIO);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_KVM_STDIO);
}
if (version >= 10000)
- qemuCapsSet(flags, QEMU_CAPS_0_10);
+ qemuCapsSet(caps, QEMU_CAPS_0_10);
if (version >= 11000)
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_BLK_SG_IO);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_SG_IO);
/* While JSON mode was available in 0.12.0, it was too
* incomplete to contemplate using. The 0.13.0 release
@@ -1220,11 +1242,11 @@ qemuCapsComputeCmdFlags(const char *help,
*/
#if HAVE_YAJL
if (version >= 13000) {
- qemuCapsSet(flags, QEMU_CAPS_MONITOR_JSON);
+ qemuCapsSet(caps, QEMU_CAPS_MONITOR_JSON);
} else if (version >= 12000 &&
strstr(help, "libvirt")) {
- qemuCapsSet(flags, QEMU_CAPS_MONITOR_JSON);
- qemuCapsSet(flags, QEMU_CAPS_NETDEV);
+ qemuCapsSet(caps, QEMU_CAPS_MONITOR_JSON);
+ qemuCapsSet(caps, QEMU_CAPS_NETDEV);
}
#else
/* Starting with qemu 0.15 and newer, upstream qemu no longer
@@ -1243,12 +1265,12 @@ qemuCapsComputeCmdFlags(const char *help,
"compiled with yajl"));
return -1;
}
- qemuCapsSet(flags, QEMU_CAPS_NETDEV);
+ qemuCapsSet(caps, QEMU_CAPS_NETDEV);
}
#endif
if (version >= 13000)
- qemuCapsSet(flags, QEMU_CAPS_PCI_MULTIFUNCTION);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_MULTIFUNCTION);
/* Although very new versions of qemu advertise the presence of
* the rombar option in the output of "qemu -device pci-assign,?",
@@ -1261,10 +1283,10 @@ qemuCapsComputeCmdFlags(const char *help,
* log and refuse to start, so it would be immediately obvious).
*/
if (version >= 12000)
- qemuCapsSet(flags, QEMU_CAPS_PCI_ROMBAR);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_ROMBAR);
if (version >= 11000)
- qemuCapsSet(flags, QEMU_CAPS_CPU_HOST);
+ qemuCapsSet(caps, QEMU_CAPS_CPU_HOST);
return 0;
}
@@ -1294,7 +1316,7 @@ qemuCapsComputeCmdFlags(const char *help,
int qemuCapsParseHelpStr(const char *qemu,
const char *help,
- virBitmapPtr flags,
+ qemuCapsPtr caps,
unsigned int *version,
unsigned int *is_kvm,
unsigned int *kvm_version,
@@ -1355,10 +1377,10 @@ int qemuCapsParseHelpStr(const char *qemu,
*version = (major * 1000 * 1000) + (minor * 1000) + micro;
if (qemuCapsComputeCmdFlags(help, *version, *is_kvm, *kvm_version,
- flags, check_yajl) < 0)
+ caps, check_yajl) < 0)
goto cleanup;
- strflags = virBitmapString(flags);
+ strflags = virBitmapString(caps->flags);
VIR_DEBUG("Version %u.%u.%u, cooked version %u, flags %s",
major, minor, micro, *version, NULLSTR(strflags));
VIR_FREE(strflags);
@@ -1385,7 +1407,7 @@ cleanup:
static int
qemuCapsExtractDeviceStr(const char *qemu,
- virBitmapPtr flags)
+ qemuCapsPtr caps)
{
char *output = NULL;
virCommandPtr cmd;
@@ -1399,7 +1421,7 @@ qemuCapsExtractDeviceStr(const char *qemu,
* understand '-device name,?', and always exits with status 1 for
* the simpler '-device ?', so this function is really only useful
* if -help includes "device driver,?". */
- cmd = qemuCapsProbeCommand(qemu, flags);
+ cmd = qemuCapsProbeCommand(qemu, caps);
virCommandAddArgList(cmd,
"-device", "?",
"-device", "pci-assign,?",
@@ -1414,7 +1436,7 @@ qemuCapsExtractDeviceStr(const char *qemu,
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
- ret = qemuCapsParseDeviceStr(output, flags);
+ ret = qemuCapsParseDeviceStr(output, caps);
cleanup:
VIR_FREE(output);
@@ -1424,85 +1446,85 @@ cleanup:
int
-qemuCapsParseDeviceStr(const char *str, virBitmapPtr flags)
+qemuCapsParseDeviceStr(const char *str, qemuCapsPtr caps)
{
/* Which devices exist. */
if (strstr(str, "name \"hda-duplex\""))
- qemuCapsSet(flags, QEMU_CAPS_HDA_DUPLEX);
+ qemuCapsSet(caps, QEMU_CAPS_HDA_DUPLEX);
if (strstr(str, "name \"hda-micro\""))
- qemuCapsSet(flags, QEMU_CAPS_HDA_MICRO);
+ qemuCapsSet(caps, QEMU_CAPS_HDA_MICRO);
if (strstr(str, "name \"ccid-card-emulated\""))
- qemuCapsSet(flags, QEMU_CAPS_CCID_EMULATED);
+ qemuCapsSet(caps, QEMU_CAPS_CCID_EMULATED);
if (strstr(str, "name \"ccid-card-passthru\""))
- qemuCapsSet(flags, QEMU_CAPS_CCID_PASSTHRU);
+ qemuCapsSet(caps, QEMU_CAPS_CCID_PASSTHRU);
if (strstr(str, "name \"piix3-usb-uhci\""))
- qemuCapsSet(flags, QEMU_CAPS_PIIX3_USB_UHCI);
+ qemuCapsSet(caps, QEMU_CAPS_PIIX3_USB_UHCI);
if (strstr(str, "name \"piix4-usb-uhci\""))
- qemuCapsSet(flags, QEMU_CAPS_PIIX4_USB_UHCI);
+ qemuCapsSet(caps, QEMU_CAPS_PIIX4_USB_UHCI);
if (strstr(str, "name \"usb-ehci\""))
- qemuCapsSet(flags, QEMU_CAPS_USB_EHCI);
+ qemuCapsSet(caps, QEMU_CAPS_USB_EHCI);
if (strstr(str, "name \"ich9-usb-ehci1\""))
- qemuCapsSet(flags, QEMU_CAPS_ICH9_USB_EHCI1);
+ qemuCapsSet(caps, QEMU_CAPS_ICH9_USB_EHCI1);
if (strstr(str, "name \"vt82c686b-usb-uhci\""))
- qemuCapsSet(flags, QEMU_CAPS_VT82C686B_USB_UHCI);
+ qemuCapsSet(caps, QEMU_CAPS_VT82C686B_USB_UHCI);
if (strstr(str, "name \"pci-ohci\""))
- qemuCapsSet(flags, QEMU_CAPS_PCI_OHCI);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_OHCI);
if (strstr(str, "name \"nec-usb-xhci\""))
- qemuCapsSet(flags, QEMU_CAPS_NEC_USB_XHCI);
+ qemuCapsSet(caps, QEMU_CAPS_NEC_USB_XHCI);
if (strstr(str, "name \"usb-redir\""))
- qemuCapsSet(flags, QEMU_CAPS_USB_REDIR);
+ qemuCapsSet(caps, QEMU_CAPS_USB_REDIR);
if (strstr(str, "name \"usb-hub\""))
- qemuCapsSet(flags, QEMU_CAPS_USB_HUB);
+ qemuCapsSet(caps, QEMU_CAPS_USB_HUB);
if (strstr(str, "name \"ich9-ahci\""))
- qemuCapsSet(flags, QEMU_CAPS_ICH9_AHCI);
+ qemuCapsSet(caps, QEMU_CAPS_ICH9_AHCI);
if (strstr(str, "name \"virtio-blk-s390\"") ||
strstr(str, "name \"virtio-net-s390\"") ||
strstr(str, "name \"virtio-serial-s390\""))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_S390);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_S390);
if (strstr(str, "name \"lsi53c895a\""))
- qemuCapsSet(flags, QEMU_CAPS_SCSI_LSI);
+ qemuCapsSet(caps, QEMU_CAPS_SCSI_LSI);
if (strstr(str, "name \"virtio-scsi-pci\""))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_SCSI_PCI);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_SCSI_PCI);
/* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
- if (!qemuCapsGet(flags, QEMU_CAPS_CHARDEV_SPICEVMC) &&
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV_SPICEVMC) &&
strstr(str, "name \"spicevmc\""))
- qemuCapsSet(flags, QEMU_CAPS_DEVICE_SPICEVMC);
+ qemuCapsSet(caps, QEMU_CAPS_DEVICE_SPICEVMC);
/* Features of given devices. */
if (strstr(str, "pci-assign.configfd"))
- qemuCapsSet(flags, QEMU_CAPS_PCI_CONFIGFD);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_CONFIGFD);
if (strstr(str, "virtio-blk-pci.multifunction"))
- qemuCapsSet(flags, QEMU_CAPS_PCI_MULTIFUNCTION);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_MULTIFUNCTION);
if (strstr(str, "virtio-blk-pci.bootindex")) {
- qemuCapsSet(flags, QEMU_CAPS_BOOTINDEX);
+ qemuCapsSet(caps, QEMU_CAPS_BOOTINDEX);
if (strstr(str, "pci-assign.bootindex"))
- qemuCapsSet(flags, QEMU_CAPS_PCI_BOOTINDEX);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_BOOTINDEX);
}
if (strstr(str, "virtio-net-pci.tx="))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_TX_ALG);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_TX_ALG);
if (strstr(str, "name \"qxl-vga\""))
- qemuCapsSet(flags, QEMU_CAPS_DEVICE_QXL_VGA);
+ qemuCapsSet(caps, QEMU_CAPS_DEVICE_QXL_VGA);
if (strstr(str, "virtio-blk-pci.ioeventfd"))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_IOEVENTFD);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_IOEVENTFD);
if (strstr(str, "name \"sga\""))
- qemuCapsSet(flags, QEMU_CAPS_SGA);
+ qemuCapsSet(caps, QEMU_CAPS_SGA);
if (strstr(str, "virtio-blk-pci.event_idx"))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX);
if (strstr(str, "virtio-net-pci.event_idx"))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_NET_EVENT_IDX);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX);
if (strstr(str, "virtio-blk-pci.scsi"))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_BLK_SCSI);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_SCSI);
if (strstr(str, "scsi-disk.channel"))
- qemuCapsSet(flags, QEMU_CAPS_SCSI_DISK_CHANNEL);
+ qemuCapsSet(caps, QEMU_CAPS_SCSI_DISK_CHANNEL);
if (strstr(str, "scsi-block"))
- qemuCapsSet(flags, QEMU_CAPS_SCSI_BLOCK);
+ qemuCapsSet(caps, QEMU_CAPS_SCSI_BLOCK);
if (strstr(str, "scsi-cd"))
- qemuCapsSet(flags, QEMU_CAPS_SCSI_CD);
+ qemuCapsSet(caps, QEMU_CAPS_SCSI_CD);
if (strstr(str, "ide-cd"))
- qemuCapsSet(flags, QEMU_CAPS_IDE_CD);
+ qemuCapsSet(caps, QEMU_CAPS_IDE_CD);
/*
* the iolimit detection is not really straight forward:
* in qemu this is a capability of the block layer, if
@@ -1512,11 +1534,11 @@ qemuCapsParseDeviceStr(const char *str, virBitmapPtr flags)
*/
if (strstr(str, ".logical_block_size") &&
strstr(str, ".physical_block_size"))
- qemuCapsSet(flags, QEMU_CAPS_BLOCKIO);
+ qemuCapsSet(caps, QEMU_CAPS_BLOCKIO);
if (strstr(str, "PIIX4_PM.disable_s3="))
- qemuCapsSet(flags, QEMU_CAPS_DISABLE_S3);
+ qemuCapsSet(caps, QEMU_CAPS_DISABLE_S3);
if (strstr(str, "PIIX4_PM.disable_s4="))
- qemuCapsSet(flags, QEMU_CAPS_DISABLE_S4);
+ qemuCapsSet(caps, QEMU_CAPS_DISABLE_S4);
return 0;
}
@@ -1525,16 +1547,16 @@ int qemuCapsExtractVersionInfo(const char *qemu,
const char *arch,
bool check_yajl,
unsigned int *retversion,
- virBitmapPtr *retflags)
+ qemuCapsPtr *retcaps)
{
int ret = -1;
unsigned int version, is_kvm, kvm_version;
- virBitmapPtr flags = NULL;
+ qemuCapsPtr caps = NULL;
char *help = NULL;
virCommandPtr cmd;
- if (retflags)
- *retflags = NULL;
+ if (retcaps)
+ *retcaps = NULL;
if (retversion)
*retversion = 0;
@@ -1554,8 +1576,8 @@ int qemuCapsExtractVersionInfo(const char *qemu,
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
- if (!(flags = qemuCapsNew()) ||
- qemuCapsParseHelpStr(qemu, help, flags,
+ if (!(caps = qemuCapsNew()) ||
+ qemuCapsParseHelpStr(qemu, help, caps,
&version, &is_kvm, &kvm_version,
check_yajl) == -1)
goto cleanup;
@@ -1563,26 +1585,26 @@ int qemuCapsExtractVersionInfo(const char *qemu,
/* Currently only x86_64 and i686 support PCI-multibus. */
if (STREQLEN(arch, "x86_64", 6) ||
STREQLEN(arch, "i686", 4)) {
- qemuCapsSet(flags, QEMU_CAPS_PCI_MULTIBUS);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_MULTIBUS);
}
/* S390 and probably other archs do not support no-acpi -
maybe the qemu option parsing should be re-thought. */
if (STRPREFIX(arch, "s390"))
- qemuCapsClear(flags, QEMU_CAPS_NO_ACPI);
+ qemuCapsClear(caps, QEMU_CAPS_NO_ACPI);
- /* qemuCapsExtractDeviceStr will only set additional flags if qemu
+ /* qemuCapsExtractDeviceStr will only set additional caps if qemu
* understands the 0.13.0+ notion of "-device driver,". */
- if (qemuCapsGet(flags, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE) &&
strstr(help, "-device driver,?") &&
- qemuCapsExtractDeviceStr(qemu, flags) < 0)
+ qemuCapsExtractDeviceStr(qemu, caps) < 0)
goto cleanup;
if (retversion)
*retversion = version;
- if (retflags) {
- *retflags = flags;
- flags = NULL;
+ if (retcaps) {
+ *retcaps = caps;
+ caps = NULL;
}
ret = 0;
@@ -1590,7 +1612,7 @@ int qemuCapsExtractVersionInfo(const char *qemu,
cleanup:
VIR_FREE(help);
virCommandFree(cmd);
- qemuCapsFree(flags);
+ virObjectUnref(caps);
return ret;
}
@@ -1644,54 +1666,80 @@ int qemuCapsExtractVersion(virCapsPtr caps,
}
-virBitmapPtr
+
+
+qemuCapsPtr
qemuCapsNew(void)
{
- virBitmapPtr caps;
+ qemuCapsPtr caps;
- if (!(caps = virBitmapAlloc(QEMU_CAPS_LAST)))
- virReportOOMError();
+ if (qemuCapsInitialize() < 0)
+ return NULL;
+
+ if (!(caps = virObjectNew(qemuCapsClass)))
+ return NULL;
+
+ if (!(caps->flags = virBitmapAlloc(QEMU_CAPS_LAST)))
+ goto no_memory;
return caps;
+
+no_memory:
+ virReportOOMError();
+ virObjectUnref(caps);
+ return NULL;
}
+void qemuCapsDispose(void *obj)
+{
+ qemuCapsPtr caps = obj;
+
+ virBitmapFree(caps->flags);
+}
+
void
-qemuCapsSet(virBitmapPtr caps,
+qemuCapsSet(qemuCapsPtr caps,
enum qemuCapsFlags flag)
{
- ignore_value(virBitmapSetBit(caps, flag));
+ ignore_value(virBitmapSetBit(caps->flags, flag));
}
void
-qemuCapsSetList(virBitmapPtr caps, ...)
+qemuCapsSetList(qemuCapsPtr caps, ...)
{
va_list list;
int flag;
va_start(list, caps);
while ((flag = va_arg(list, int)) < QEMU_CAPS_LAST)
- ignore_value(virBitmapSetBit(caps, flag));
+ ignore_value(virBitmapSetBit(caps->flags, flag));
va_end(list);
}
void
-qemuCapsClear(virBitmapPtr caps,
+qemuCapsClear(qemuCapsPtr caps,
enum qemuCapsFlags flag)
{
- ignore_value(virBitmapClearBit(caps, flag));
+ ignore_value(virBitmapClearBit(caps->flags, flag));
+}
+
+
+char *qemuCapsFlagsString(qemuCapsPtr caps)
+{
+ return virBitmapString(caps->flags);
}
bool
-qemuCapsGet(virBitmapPtr caps,
+qemuCapsGet(qemuCapsPtr caps,
enum qemuCapsFlags flag)
{
bool b;
- if (!caps || virBitmapGetBit(caps, flag, &b) < 0)
+ if (!caps || virBitmapGetBit(caps->flags, flag, &b) < 0)
return false;
else
return b;
@@ -1700,14 +1748,14 @@ qemuCapsGet(virBitmapPtr caps,
virCommandPtr
qemuCapsProbeCommand(const char *qemu,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virCommandPtr cmd = virCommandNew(qemu);
- if (qemuCaps) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG))
+ if (caps) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_USER_CONFIG))
virCommandAddArg(cmd, "-no-user-config");
- else if (qemuCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
+ else if (qemuCapsGet(caps, QEMU_CAPS_NODEFCONFIG))
virCommandAddArg(cmd, "-nodefconfig");
}
diff --git a/src/qemu/qemu_capabilities.h b/src/qemu/qemu_capabilities.h
index 49d64e5..1e817c6 100644
--- a/src/qemu/qemu_capabilities.h
+++ b/src/qemu/qemu_capabilities.h
@@ -24,7 +24,7 @@
#ifndef __QEMU_CAPABILITIES_H__
# define __QEMU_CAPABILITIES_H__
-# include "bitmap.h"
+# include "virobject.h"
# include "capabilities.h"
# include "command.h"
@@ -145,30 +145,33 @@ enum qemuCapsFlags {
QEMU_CAPS_LAST, /* this must always be the last item */
};
-virBitmapPtr qemuCapsNew(void);
+typedef struct _qemuCaps qemuCaps;
+typedef qemuCaps *qemuCapsPtr;
-# define qemuCapsFree(caps) virBitmapFree(caps)
+qemuCapsPtr qemuCapsNew(void);
-void qemuCapsSet(virBitmapPtr caps,
+void qemuCapsSet(qemuCapsPtr caps,
enum qemuCapsFlags flag) ATTRIBUTE_NONNULL(1);
-void qemuCapsSetList(virBitmapPtr caps, ...) ATTRIBUTE_NONNULL(1);
+void qemuCapsSetList(qemuCapsPtr caps, ...) ATTRIBUTE_NONNULL(1);
-void qemuCapsClear(virBitmapPtr caps,
+void qemuCapsClear(qemuCapsPtr caps,
enum qemuCapsFlags flag) ATTRIBUTE_NONNULL(1);
-bool qemuCapsGet(virBitmapPtr caps,
+bool qemuCapsGet(qemuCapsPtr caps,
enum qemuCapsFlags flag);
+char *qemuCapsFlagsString(qemuCapsPtr caps);
+
virCapsPtr qemuCapsInit(virCapsPtr old_caps);
int qemuCapsProbeMachineTypes(const char *binary,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virCapsGuestMachinePtr **machines,
int *nmachines);
int qemuCapsProbeCPUModels(const char *qemu,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const char *arch,
unsigned int *count,
const char ***cpus);
@@ -179,20 +182,20 @@ int qemuCapsExtractVersionInfo(const char *qemu,
const char *arch,
bool check_yajl,
unsigned int *version,
- virBitmapPtr *qemuCaps);
+ qemuCapsPtr *retcaps);
int qemuCapsParseHelpStr(const char *qemu,
const char *str,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
unsigned int *version,
unsigned int *is_kvm,
unsigned int *kvm_version,
bool check_yajl);
int qemuCapsParseDeviceStr(const char *str,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
virCommandPtr qemuCapsProbeCommand(const char *qemu,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
VIR_ENUM_DECL(qemuCaps);
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index a83d6de..5b4aeda 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -149,14 +149,14 @@ int
qemuPhysIfaceConnect(virDomainDefPtr def,
struct qemud_driver *driver,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
enum virNetDevVPortProfileOp vmop)
{
int rc;
char *res_ifname = NULL;
int vnet_hdr = 0;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_VNET_HDR) &&
net->model && STREQ(net->model, "virtio"))
vnet_hdr = 1;
@@ -184,7 +184,7 @@ qemuNetworkIfaceConnect(virDomainDefPtr def,
virConnectPtr conn,
struct qemud_driver *driver,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
char *brname = NULL;
int err;
@@ -250,7 +250,7 @@ qemuNetworkIfaceConnect(virDomainDefPtr def,
template_ifname = true;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_VNET_HDR) &&
net->model && STREQ(net->model, "virtio")) {
tap_create_flags |= VIR_NETDEV_TAP_CREATE_VNET_HDR;
}
@@ -302,7 +302,7 @@ cleanup:
int
qemuOpenVhostNet(virDomainDefPtr def,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *vhostfd)
{
*vhostfd = -1; /* assume we won't use vhost */
@@ -315,9 +315,9 @@ qemuOpenVhostNet(virDomainDefPtr def,
/* If qemu doesn't support vhost-net mode (including the -netdev command
* option), don't try to open the device.
*/
- if (!(qemuCapsGet(qemuCaps, QEMU_CAPS_VHOST_NET) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))) {
+ if (!(qemuCapsGet(caps, QEMU_CAPS_VHOST_NET) &&
+ qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE))) {
if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("vhost-net is not supported with "
@@ -400,11 +400,11 @@ static int qemuAssignDeviceDiskAliasLegacy(virDomainDiskDefPtr disk)
char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
char *ret;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (virAsprintf(&ret, "%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias) < 0) {
virReportOOMError();
return NULL;
@@ -474,13 +474,13 @@ static int qemuAssignDeviceDiskAliasFixed(virDomainDiskDefPtr disk)
static int
qemuSetScsiControllerModel(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *model)
{
if (*model > 0) {
switch (*model) {
case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_LSI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support "
"lsi scsi controller"));
@@ -488,7 +488,7 @@ qemuSetScsiControllerModel(virDomainDefPtr def,
}
break;
case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_SCSI_PCI)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_VIRTIO_SCSI_PCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support "
"virtio scsi controller"));
@@ -508,7 +508,7 @@ qemuSetScsiControllerModel(virDomainDefPtr def,
if (STREQ(def->os.arch, "ppc64") &&
STREQ(def->os.machine, "pseries")) {
*model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI;
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_SCSI_LSI)) {
*model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC;
} else {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@@ -524,7 +524,7 @@ qemuSetScsiControllerModel(virDomainDefPtr def,
static int
qemuAssignDeviceDiskAliasCustom(virDomainDefPtr def,
virDomainDiskDefPtr disk,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
const char *prefix = virDomainDiskBusTypeToString(disk->bus);
int controllerModel = -1;
@@ -535,7 +535,7 @@ qemuAssignDeviceDiskAliasCustom(virDomainDefPtr def,
virDomainDiskFindControllerModel(def, disk,
VIR_DOMAIN_CONTROLLER_TYPE_SCSI);
- if ((qemuSetScsiControllerModel(def, qemuCaps, &controllerModel)) < 0)
+ if ((qemuSetScsiControllerModel(def, caps, &controllerModel)) < 0)
return -1;
}
@@ -571,11 +571,11 @@ no_memory:
int
qemuAssignDeviceDiskAlias(virDomainDefPtr vmdef,
virDomainDiskDefPtr def,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
- return qemuAssignDeviceDiskAliasCustom(vmdef, def, qemuCaps);
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE))
+ return qemuAssignDeviceDiskAliasCustom(vmdef, def, caps);
else
return qemuAssignDeviceDiskAliasFixed(def);
} else {
@@ -686,16 +686,16 @@ qemuAssignDeviceControllerAlias(virDomainControllerDefPtr controller)
int
-qemuAssignDeviceAliases(virDomainDefPtr def, virBitmapPtr qemuCaps)
+qemuAssignDeviceAliases(virDomainDefPtr def, qemuCapsPtr caps)
{
int i;
for (i = 0; i < def->ndisks ; i++) {
- if (qemuAssignDeviceDiskAlias(def, def->disks[i], qemuCaps) < 0)
+ if (qemuAssignDeviceDiskAlias(def, def->disks[i], caps) < 0)
return -1;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NET_NAME) ||
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NET_NAME) ||
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
for (i = 0; i < def->nnets ; i++) {
/* type='hostdev' interfaces are also on the hostdevs list,
* and will have their alias assigned with other hostdevs.
@@ -707,7 +707,7 @@ qemuAssignDeviceAliases(virDomainDefPtr def, virBitmapPtr qemuCaps)
}
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
return 0;
for (i = 0; i < def->nfss ; i++) {
@@ -811,21 +811,21 @@ qemuDomainPrimeS390VirtioDevices(virDomainDefPtr def,
}
static int
-qemuDomainAssignS390Addresses(virDomainDefPtr def, virBitmapPtr qemuCaps)
+qemuDomainAssignS390Addresses(virDomainDefPtr def, qemuCapsPtr caps)
{
int ret = -1;
- virBitmapPtr localCaps = NULL;
+ qemuCapsPtr localCaps = NULL;
- if (!qemuCaps) {
+ if (!caps) {
/* need to get information from real environment */
if (qemuCapsExtractVersionInfo(def->emulator, def->os.arch,
false, NULL,
&localCaps) < 0)
goto cleanup;
- qemuCaps = localCaps;
+ caps = localCaps;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_S390)) {
/* deal with legacy virtio-s390 */
qemuDomainPrimeS390VirtioDevices(
def, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390);
@@ -834,7 +834,7 @@ qemuDomainAssignS390Addresses(virDomainDefPtr def, virBitmapPtr qemuCaps)
ret = 0;
cleanup:
- qemuCapsFree(localCaps);
+ virObjectUnref(localCaps);
return ret;
}
@@ -893,21 +893,21 @@ qemuAssignSpaprVIOAddress(virDomainDefPtr def, virDomainDeviceInfoPtr info,
}
int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
int i, rc = -1;
int model;
- virBitmapPtr localCaps = NULL;
+ qemuCapsPtr localCaps = NULL;
/* Default values match QEMU. See spapr_(llan|vscsi|vty).c */
- if (!qemuCaps) {
+ if (!caps) {
/* need to get information from real environment */
if (qemuCapsExtractVersionInfo(def->emulator, def->os.arch,
false, NULL,
&localCaps) < 0)
goto cleanup;
- qemuCaps = localCaps;
+ caps = localCaps;
}
for (i = 0 ; i < def->nnets; i++) {
@@ -923,7 +923,7 @@ int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
for (i = 0 ; i < def->ncontrollers; i++) {
model = def->controllers[i]->model;
if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
- rc = qemuSetScsiControllerModel(def, qemuCaps, &model);
+ rc = qemuSetScsiControllerModel(def, caps, &model);
if (rc)
goto cleanup;
}
@@ -954,7 +954,7 @@ int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
rc = 0;
cleanup:
- qemuCapsFree(localCaps);
+ virObjectUnref(localCaps);
return rc;
}
@@ -1065,25 +1065,25 @@ cleanup:
int
qemuDomainAssignPCIAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virDomainObjPtr obj)
{
int ret = -1;
- virBitmapPtr localCaps = NULL;
+ qemuCapsPtr localCaps = NULL;
qemuDomainPCIAddressSetPtr addrs = NULL;
qemuDomainObjPrivatePtr priv = NULL;
- if (!qemuCaps) {
+ if (!caps) {
/* need to get information from real environment */
if (qemuCapsExtractVersionInfo(def->emulator, def->os.arch,
false,
NULL,
&localCaps) < 0)
goto cleanup;
- qemuCaps = localCaps;
+ caps = localCaps;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (!(addrs = qemuDomainPCIAddressSetCreate(def)))
goto cleanup;
@@ -1107,27 +1107,27 @@ qemuDomainAssignPCIAddresses(virDomainDefPtr def,
ret = 0;
cleanup:
- qemuCapsFree(localCaps);
+ virObjectUnref(localCaps);
qemuDomainPCIAddressSetFree(addrs);
return ret;
}
int qemuDomainAssignAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virDomainObjPtr obj)
{
int rc;
- rc = qemuDomainAssignSpaprVIOAddresses(def, qemuCaps);
+ rc = qemuDomainAssignSpaprVIOAddresses(def, caps);
if (rc)
return rc;
- rc = qemuDomainAssignS390Addresses(def, qemuCaps);
+ rc = qemuDomainAssignS390Addresses(def, caps);
if (rc)
return rc;
- return qemuDomainAssignPCIAddresses(def, qemuCaps, obj);
+ return qemuDomainAssignPCIAddresses(def, caps, obj);
}
static void
@@ -1756,7 +1756,7 @@ qemuUsbId(virBufferPtr buf, int idx)
static int
qemuBuildDeviceAddressStr(virBufferPtr buf,
virDomainDeviceInfoPtr info,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
if (info->addr.pci.domain != 0) {
@@ -1769,7 +1769,7 @@ qemuBuildDeviceAddressStr(virBufferPtr buf,
_("Only PCI device addresses with bus=0 are supported"));
return -1;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIFUNCTION)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_PCI_MULTIFUNCTION)) {
if (info->addr.pci.function > 7) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("The function of PCI device addresses must "
@@ -1797,7 +1797,7 @@ qemuBuildDeviceAddressStr(virBufferPtr buf,
* When QEMU grows support for > 1 PCI domain, then pci.0 change
* to pciNN.0 where NN is the domain number
*/
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS))
+ if (qemuCapsGet(caps, QEMU_CAPS_PCI_MULTIBUS))
virBufferAsprintf(buf, ",bus=pci.0");
else
virBufferAsprintf(buf, ",bus=pci");
@@ -1823,7 +1823,7 @@ qemuBuildDeviceAddressStr(virBufferPtr buf,
static int
qemuBuildRomStr(virBufferPtr buf,
virDomainDeviceInfoPtr info,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
if (info->rombar || info->romfile) {
if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
@@ -1831,7 +1831,7 @@ qemuBuildRomStr(virBufferPtr buf,
"%s", _("rombar and romfile are supported only for PCI devices"));
return -1;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_ROMBAR)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_PCI_ROMBAR)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("rombar and romfile not supported in this QEMU binary"));
return -1;
@@ -1856,9 +1856,9 @@ qemuBuildRomStr(virBufferPtr buf,
static int
qemuBuildIoEventFdStr(virBufferPtr buf,
enum virDomainIoEventFd use,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
- if (use && qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_IOEVENTFD))
+ if (use && qemuCapsGet(caps, QEMU_CAPS_VIRTIO_IOEVENTFD))
virBufferAsprintf(buf, ",ioeventfd=%s",
virDomainIoEventFdTypeToString(use));
return 0;
@@ -2073,7 +2073,7 @@ char *
qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
virDomainDiskDefPtr disk,
bool bootable,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
@@ -2152,7 +2152,7 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
break;
case VIR_DOMAIN_DISK_BUS_VIRTIO:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_S390) &&
(disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390)) {
/* Paranoia - leave in here for now */
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@@ -2233,24 +2233,24 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
virBufferEscape(&opt, ',', ",", "file=%s,", disk->src);
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE))
virBufferAddLit(&opt, "if=none");
else
virBufferAsprintf(&opt, "if=%s", bus);
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
if ((disk->bus == VIR_DOMAIN_DISK_BUS_SCSI)) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD))
+ if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_CD))
virBufferAddLit(&opt, ",media=cdrom");
} else if (disk->bus == VIR_DOMAIN_DISK_BUS_IDE) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_IDE_CD))
+ if (!qemuCapsGet(caps, QEMU_CAPS_IDE_CD))
virBufferAddLit(&opt, ",media=cdrom");
} else {
virBufferAddLit(&opt, ",media=cdrom");
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virBufferAsprintf(&opt, ",id=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
} else {
if (busid == -1 && unitid == -1) {
@@ -2264,13 +2264,13 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
}
}
if (bootable &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) &&
+ qemuCapsGet(caps, QEMU_CAPS_DRIVE_BOOT) &&
(disk->device == VIR_DOMAIN_DISK_DEVICE_DISK ||
disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) &&
disk->bus != VIR_DOMAIN_DISK_BUS_IDE)
virBufferAddLit(&opt, ",boot=on");
if (disk->readonly &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_READONLY))
+ qemuCapsGet(caps, QEMU_CAPS_DRIVE_READONLY))
virBufferAddLit(&opt, ",readonly=on");
if (disk->transient) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
@@ -2279,7 +2279,7 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
}
if (disk->driverType && *disk->driverType != '\0' &&
disk->type != VIR_DOMAIN_DISK_TYPE_DIR &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT))
+ qemuCapsGet(caps, QEMU_CAPS_DRIVE_FORMAT))
virBufferAsprintf(&opt, ",format=%s", disk->driverType);
/* generate geometry command string */
@@ -2297,7 +2297,7 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
}
if (disk->serial &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL)) {
+ qemuCapsGet(caps, QEMU_CAPS_DRIVE_SERIAL)) {
if (qemuSafeSerialParamValue(disk->serial) < 0)
goto error;
virBufferAsprintf(&opt, ",serial=%s", disk->serial);
@@ -2306,17 +2306,17 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
if (disk->cachemode) {
const char *mode = NULL;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE_CACHE_V2)) {
mode = qemuDiskCacheV2TypeToString(disk->cachemode);
if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_DIRECTSYNC &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC)) {
+ !qemuCapsGet(caps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk cache mode 'directsync' is not "
"supported by this QEMU"));
goto error;
} else if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_UNSAFE &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE)) {
+ !qemuCapsGet(caps, QEMU_CAPS_DRIVE_CACHE_UNSAFE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk cache mode 'unsafe' is not "
"supported by this QEMU"));
@@ -2332,7 +2332,7 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
}
if (disk->copy_on_read) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE_COPY_ON_READ)) {
virBufferAsprintf(&opt, ",copy-on-read=%s",
virDomainDiskCopyOnReadTypeToString(disk->copy_on_read));
} else {
@@ -2342,7 +2342,7 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_MONITOR_JSON)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_MONITOR_JSON)) {
const char *wpolicy = NULL, *rpolicy = NULL;
if (disk->error_policy)
@@ -2368,7 +2368,7 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
}
if (disk->iomode) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_AIO)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE_AIO)) {
virBufferAsprintf(&opt, ",aio=%s",
virDomainDiskIoTypeToString(disk->iomode));
} else {
@@ -2386,7 +2386,7 @@ qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
disk->blkdeviotune.total_iops_sec ||
disk->blkdeviotune.read_iops_sec ||
disk->blkdeviotune.write_iops_sec) &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
+ !qemuCapsGet(caps, QEMU_CAPS_DRIVE_IOTUNE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block I/O throttling not supported with this "
"QEMU binary"));
@@ -2439,7 +2439,7 @@ char *
qemuBuildDriveDevStr(virDomainDefPtr def,
virDomainDiskDefPtr disk,
int bootindex,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
@@ -2469,7 +2469,7 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
virDomainDiskTypeToString(disk->type));
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_VIRTIO_BLK_SG_IO)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk device='lun' is not supported by this QEMU"));
goto error;
@@ -2484,7 +2484,7 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
goto error;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_IDE_CD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_IDE_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "ide-cd");
else
@@ -2499,7 +2499,7 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
break;
case VIR_DOMAIN_DISK_BUS_SCSI:
if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_BLOCK)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_BLOCK)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support scsi-block for "
"lun passthrough"));
@@ -2510,7 +2510,7 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
controllerModel =
virDomainDiskFindControllerModel(def, disk,
VIR_DOMAIN_CONTROLLER_TYPE_SCSI);
- if ((qemuSetScsiControllerModel(def, qemuCaps, &controllerModel)) < 0)
+ if ((qemuSetScsiControllerModel(def, caps, &controllerModel)) < 0)
goto error;
if (controllerModel == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
@@ -2524,7 +2524,7 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
virBufferAddLit(&opt, "scsi-block");
} else {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_SCSI_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "scsi-cd");
else
@@ -2539,7 +2539,7 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
disk->info.addr.drive.bus,
disk->info.addr.drive.unit);
} else {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_CHANNEL)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_DISK_CHANNEL)) {
if (disk->info.addr.drive.target > 7) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support target "
@@ -2557,7 +2557,7 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
}
if (disk->device != VIR_DOMAIN_DISK_DEVICE_LUN) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_SCSI_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "scsi-cd");
else
@@ -2588,7 +2588,7 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
goto error;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_IDE_CD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_IDE_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "ide-cd");
else
@@ -2608,13 +2608,13 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
} else {
virBufferAddLit(&opt, "virtio-blk-pci");
}
- qemuBuildIoEventFdStr(&opt, disk->ioeventfd, qemuCaps);
+ qemuBuildIoEventFdStr(&opt, disk->ioeventfd, caps);
if (disk->event_idx &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX)) {
+ qemuCapsGet(caps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX)) {
virBufferAsprintf(&opt, ",event_idx=%s",
virDomainVirtioEventIdxTypeToString(disk->event_idx));
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SCSI)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_BLK_SCSI)) {
/* if sg_io is true but the scsi option isn't supported,
* that means it's just always on in this version of qemu.
*/
@@ -2622,7 +2622,7 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
(disk->device == VIR_DOMAIN_DISK_DEVICE_LUN)
? "on" : "off");
}
- if (qemuBuildDeviceAddressStr(&opt, &disk->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&opt, &disk->info, caps) < 0)
goto error;
break;
case VIR_DOMAIN_DISK_BUS_USB:
@@ -2635,9 +2635,9 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
}
virBufferAsprintf(&opt, ",drive=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
virBufferAsprintf(&opt, ",id=%s", disk->info.alias);
- if (bootindex && qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
+ if (bootindex && qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX))
virBufferAsprintf(&opt, ",bootindex=%d", bootindex);
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_BLOCKIO)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_BLOCKIO)) {
if (disk->blockio.logical_block_size > 0)
virBufferAsprintf(&opt, ",logical_block_size=%u",
disk->blockio.logical_block_size);
@@ -2660,7 +2660,7 @@ error:
char *qemuBuildFSStr(virDomainFSDefPtr fs,
- virBitmapPtr qemuCaps ATTRIBUTE_UNUSED)
+ qemuCapsPtr caps ATTRIBUTE_UNUSED)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
const char *driver = qemuDomainFSDriverTypeToString(fs->fsdriver);
@@ -2699,7 +2699,7 @@ char *qemuBuildFSStr(virDomainFSDefPtr fs,
}
if (fs->wrpolicy) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_FSDEV_WRITEOUT)) {
virBufferAsprintf(&opt, ",writeout=%s", wrpolicy);
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
@@ -2712,7 +2712,7 @@ char *qemuBuildFSStr(virDomainFSDefPtr fs,
virBufferAsprintf(&opt, ",path=%s", fs->src);
if (fs->readonly) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_FSDEV_READONLY)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_FSDEV_READONLY)) {
virBufferAddLit(&opt, ",readonly");
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
@@ -2737,7 +2737,7 @@ error:
char *
qemuBuildFSDevStr(virDomainFSDefPtr fs,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
@@ -2752,7 +2752,7 @@ qemuBuildFSDevStr(virDomainFSDefPtr fs,
virBufferAsprintf(&opt, ",fsdev=%s%s", QEMU_FSDEV_HOST_PREFIX, fs->info.alias);
virBufferAsprintf(&opt, ",mount_tag=%s", fs->dst);
- if (qemuBuildDeviceAddressStr(&opt, &fs->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&opt, &fs->info, caps) < 0)
goto error;
if (virBufferError(&opt)) {
@@ -2798,11 +2798,11 @@ qemuControllerModelUSBToCaps(int model)
static int
qemuBuildUSBControllerDevStr(virDomainDefPtr domainDef,
virDomainControllerDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virBuffer *buf)
{
const char *smodel;
- int model, caps;
+ int model, flags;
model = def->model;
@@ -2814,9 +2814,9 @@ qemuBuildUSBControllerDevStr(virDomainDefPtr domainDef,
}
smodel = qemuControllerModelUSBTypeToString(model);
- caps = qemuControllerModelUSBToCaps(model);
+ flags = qemuControllerModelUSBToCaps(model);
- if (caps == -1 || !qemuCapsGet(qemuCaps, caps)) {
+ if (flags == -1 || !qemuCapsGet(caps, flags)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("%s not supported in this QEMU binary"), smodel);
return -1;
@@ -2839,7 +2839,7 @@ qemuBuildUSBControllerDevStr(virDomainDefPtr domainDef,
char *
qemuBuildControllerDevStr(virDomainDefPtr domainDef,
virDomainControllerDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *nusbcontroller)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
@@ -2848,7 +2848,7 @@ qemuBuildControllerDevStr(virDomainDefPtr domainDef,
switch (def->type) {
case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
model = def->model;
- if ((qemuSetScsiControllerModel(domainDef, qemuCaps, &model)) < 0)
+ if ((qemuSetScsiControllerModel(domainDef, caps, &model)) < 0)
return NULL;
switch (model) {
@@ -2899,7 +2899,7 @@ qemuBuildControllerDevStr(virDomainDefPtr domainDef,
break;
case VIR_DOMAIN_CONTROLLER_TYPE_USB:
- if (qemuBuildUSBControllerDevStr(domainDef, def, qemuCaps, &buf) == -1)
+ if (qemuBuildUSBControllerDevStr(domainDef, def, caps, &buf) == -1)
goto error;
if (nusbcontroller)
@@ -2916,7 +2916,7 @@ qemuBuildControllerDevStr(virDomainDefPtr domainDef,
goto error;
}
- if (qemuBuildDeviceAddressStr(&buf, &def->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &def->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -2961,7 +2961,7 @@ char *
qemuBuildNicDevStr(virDomainNetDefPtr net,
int vlan,
int bootindex,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *nic;
@@ -2983,7 +2983,7 @@ qemuBuildNicDevStr(virDomainNetDefPtr net,
virBufferAdd(&buf, nic, strlen(nic));
if (usingVirtio && net->driver.virtio.txmode) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_TX_ALG)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_TX_ALG)) {
virBufferAddLit(&buf, ",tx=");
switch (net->driver.virtio.txmode) {
case VIR_DOMAIN_NET_VIRTIO_TX_MODE_IOTHREAD:
@@ -3008,9 +3008,9 @@ qemuBuildNicDevStr(virDomainNetDefPtr net,
}
}
if (usingVirtio) {
- qemuBuildIoEventFdStr(&buf, net->driver.virtio.ioeventfd, qemuCaps);
+ qemuBuildIoEventFdStr(&buf, net->driver.virtio.ioeventfd, caps);
if (net->driver.virtio.event_idx &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX)) {
+ qemuCapsGet(caps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX)) {
virBufferAsprintf(&buf, ",event_idx=%s",
virDomainVirtioEventIdxTypeToString(net->driver.virtio.event_idx));
}
@@ -3024,11 +3024,11 @@ qemuBuildNicDevStr(virDomainNetDefPtr net,
net->mac.addr[0], net->mac.addr[1],
net->mac.addr[2], net->mac.addr[3],
net->mac.addr[4], net->mac.addr[5]);
- if (qemuBuildDeviceAddressStr(&buf, &net->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &net->info, caps) < 0)
goto error;
- if (qemuBuildRomStr(&buf, &net->info, qemuCaps) < 0)
+ if (qemuBuildRomStr(&buf, &net->info, caps) < 0)
goto error;
- if (bootindex && qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
+ if (bootindex && qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX))
virBufferAsprintf(&buf, ",bootindex=%d", bootindex);
if (virBufferError(&buf)) {
@@ -3047,7 +3047,7 @@ error:
char *
qemuBuildHostNetStr(virDomainNetDefPtr net,
struct qemud_driver *driver,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
char type_sep,
int vlan,
const char *tapfd,
@@ -3073,7 +3073,7 @@ qemuBuildHostNetStr(virDomainNetDefPtr net,
*/
case VIR_DOMAIN_NET_TYPE_BRIDGE:
if (!driver->privileged &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE)) {
+ qemuCapsGet(caps, QEMU_CAPS_NETDEV_BRIDGE)) {
brname = virDomainNetGetActualBridgeName(net);
virBufferAsprintf(&buf, "bridge%cbr=%s", type_sep, brname);
type_sep = ',';
@@ -3160,7 +3160,7 @@ qemuBuildHostNetStr(virDomainNetDefPtr net,
char *
qemuBuildWatchdogDevStr(virDomainWatchdogDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
@@ -3172,7 +3172,7 @@ qemuBuildWatchdogDevStr(virDomainWatchdogDefPtr dev,
}
virBufferAsprintf(&buf, "%s,id=%s", model, dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -3190,13 +3190,13 @@ error:
char *
qemuBuildMemballoonDevStr(virDomainMemballoonDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBufferAddLit(&buf, "virtio-balloon-pci");
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -3214,7 +3214,7 @@ error:
char *
qemuBuildUSBInputDevStr(virDomainInputDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
@@ -3222,7 +3222,7 @@ qemuBuildUSBInputDevStr(virDomainInputDefPtr dev,
dev->type == VIR_DOMAIN_INPUT_TYPE_MOUSE ?
"usb-mouse" : "usb-tablet", dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -3240,7 +3240,7 @@ error:
char *
qemuBuildSoundDevStr(virDomainSoundDefPtr sound,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *model = virDomainSoundModelTypeToString(sound->model);
@@ -3260,7 +3260,7 @@ qemuBuildSoundDevStr(virDomainSoundDefPtr sound,
model = "intel-hda";
virBufferAsprintf(&buf, "%s,id=%s", model, sound->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &sound->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &sound->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -3293,17 +3293,17 @@ qemuSoundCodecTypeToCaps(int type)
static char *
qemuBuildSoundCodecStr(virDomainSoundDefPtr sound,
virDomainSoundCodecDefPtr codec,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *stype;
- int type, caps;
+ int type, flags;
type = codec->type;
stype = qemuSoundCodecTypeToString(type);
- caps = qemuSoundCodecTypeToCaps(type);
+ flags = qemuSoundCodecTypeToCaps(type);
- if (caps == -1 || !qemuCapsGet(qemuCaps, caps)) {
+ if (flags == -1 || !qemuCapsGet(caps, flags)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("%s not supported in this QEMU binary"), stype);
goto error;
@@ -3321,7 +3321,7 @@ error:
static char *
qemuBuildVideoDevStr(virDomainVideoDefPtr video,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *model = qemuVideoTypeToString(video->type);
@@ -3346,7 +3346,7 @@ qemuBuildVideoDevStr(virDomainVideoDefPtr video,
virBufferAsprintf(&buf, ",vram_size=%u", video->vram * 1024);
}
- if (qemuBuildDeviceAddressStr(&buf, &video->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &video->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -3389,7 +3389,7 @@ qemuOpenPCIConfig(virDomainHostdevDefPtr dev)
char *
qemuBuildPCIHostdevDevStr(virDomainHostdevDefPtr dev, const char *configfd,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
@@ -3403,9 +3403,9 @@ qemuBuildPCIHostdevDevStr(virDomainHostdevDefPtr dev, const char *configfd,
virBufferAsprintf(&buf, ",configfd=%s", configfd);
if (dev->info->bootIndex)
virBufferAsprintf(&buf, ",bootindex=%d", dev->info->bootIndex);
- if (qemuBuildDeviceAddressStr(&buf, dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, dev->info, caps) < 0)
goto error;
- if (qemuBuildRomStr(&buf, dev->info, qemuCaps) < 0)
+ if (qemuBuildRomStr(&buf, dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -3438,7 +3438,7 @@ qemuBuildPCIHostdevPCIDevStr(virDomainHostdevDefPtr dev)
char *
qemuBuildRedirdevDevStr(virDomainRedirdevDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
@@ -3449,7 +3449,7 @@ qemuBuildRedirdevDevStr(virDomainRedirdevDefPtr dev,
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_USB_REDIR)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("USB redirection is not supported "
"by this version of QEMU"));
@@ -3460,7 +3460,7 @@ qemuBuildRedirdevDevStr(virDomainRedirdevDefPtr dev,
dev->info.alias,
dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -3477,7 +3477,7 @@ error:
char *
qemuBuildUSBHostdevDevStr(virDomainHostdevDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
@@ -3493,7 +3493,7 @@ qemuBuildUSBHostdevDevStr(virDomainHostdevDefPtr dev,
dev->source.subsys.u.usb.device,
dev->info->alias);
- if (qemuBuildDeviceAddressStr(&buf, dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -3511,7 +3511,7 @@ error:
char *
qemuBuildHubDevStr(virDomainHubDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
@@ -3522,7 +3522,7 @@ qemuBuildHubDevStr(virDomainHubDefPtr dev,
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_USB_HUB)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_USB_HUB)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("usb-hub not supported by QEMU binary"));
goto error;
@@ -3530,7 +3530,7 @@ qemuBuildHubDevStr(virDomainHubDefPtr dev,
virBufferAddLit(&buf, "usb-hub");
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
@@ -3572,7 +3572,7 @@ qemuBuildUSBHostdevUsbDevStr(virDomainHostdevDefPtr dev)
* host side of the character device */
static char *
qemuBuildChrChardevStr(virDomainChrSourceDefPtr dev, const char *alias,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
bool telnet;
@@ -3651,7 +3651,7 @@ qemuBuildChrChardevStr(virDomainChrSourceDefPtr dev, const char *alias,
break;
case VIR_DOMAIN_CHR_TYPE_SPICEVMC:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV_SPICEVMC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("spicevmc not supported in this QEMU binary"));
goto error;
@@ -3772,7 +3772,7 @@ error:
static char *
qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
switch (dev->deviceType) {
@@ -3782,7 +3782,7 @@ qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
/* Legacy syntax '-device spicevmc' */
if (dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC)) {
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE_SPICEVMC)) {
virBufferAddLit(&buf, "spicevmc");
} else {
virBufferAddLit(&buf, "virtserialport");
@@ -3825,7 +3825,7 @@ qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
if (!(dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC))) {
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE_SPICEVMC))) {
virBufferAsprintf(&buf, ",chardev=char%s,id=%s",
dev->info.alias, dev->info.alias);
if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL) {
@@ -4031,7 +4031,7 @@ static int
qemuBuildCpuArgStr(const struct qemud_driver *driver,
const virDomainDefPtr def,
const char *emulator,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const struct utsname *ut,
char **opt,
bool *hasHwVirt,
@@ -4064,7 +4064,7 @@ qemuBuildCpuArgStr(const struct qemud_driver *driver,
int hasSVM;
if (host &&
- qemuCapsProbeCPUModels(emulator, qemuCaps, host->arch,
+ qemuCapsProbeCPUModels(emulator, caps, host->arch,
&ncpus, &cpus) < 0)
goto cleanup;
@@ -4111,7 +4111,7 @@ qemuBuildCpuArgStr(const struct qemud_driver *driver,
if (cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH) {
const char *mode = virCPUModeTypeToString(cpu->mode);
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CPU_HOST)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CPU_HOST)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("CPU mode '%s' is not supported by QEMU"
" binary"), mode);
@@ -4221,13 +4221,13 @@ no_memory:
static char *
qemuBuildSmpArgStr(const virDomainDefPtr def,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&buf, "%u", def->vcpus);
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_SMP_TOPOLOGY)) {
if (def->vcpus != def->maxvcpus)
virBufferAsprintf(&buf, ",maxcpus=%u", def->maxvcpus);
/* sockets, cores, and threads are either all zero
@@ -4335,7 +4335,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virDomainDefPtr def,
virDomainChrSourceDefPtr monitor_chr,
bool monitor_json,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const char *migrateFrom,
int migrateFd,
virDomainSnapshotObjPtr snapshot,
@@ -4367,25 +4367,25 @@ qemuBuildCommandLine(virConnectPtr conn,
* do not use boot=on for drives when not using KVM since this
* is not supported at all in upstream QEmu.
*/
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_KVM) &&
(def->virtType == VIR_DOMAIN_VIRT_QEMU))
- qemuCapsClear(qemuCaps, QEMU_CAPS_DRIVE_BOOT);
+ qemuCapsClear(caps, QEMU_CAPS_DRIVE_BOOT);
switch (def->virtType) {
case VIR_DOMAIN_VIRT_QEMU:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
+ if (qemuCapsGet(caps, QEMU_CAPS_KQEMU))
disableKQEMU = 1;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ if (qemuCapsGet(caps, QEMU_CAPS_KVM))
disableKVM = 1;
break;
case VIR_DOMAIN_VIRT_KQEMU:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ if (qemuCapsGet(caps, QEMU_CAPS_KVM))
disableKVM = 1;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KQEMU)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_ENABLE_KQEMU)) {
enableKQEMU = 1;
- } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU)) {
+ } else if (!qemuCapsGet(caps, QEMU_CAPS_KQEMU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support kqemu"),
emulator);
@@ -4393,12 +4393,12 @@ qemuBuildCommandLine(virConnectPtr conn,
break;
case VIR_DOMAIN_VIRT_KVM:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
+ if (qemuCapsGet(caps, QEMU_CAPS_KQEMU))
disableKQEMU = 1;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KVM)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_ENABLE_KVM)) {
enableKVM = 1;
- } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
+ } else if (!qemuCapsGet(caps, QEMU_CAPS_KVM)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support kvm"),
emulator);
@@ -4420,10 +4420,10 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddEnvPassCommon(cmd);
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NAME)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NAME)) {
virCommandAddArg(cmd, "-name");
if (driver->setProcessName &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_NAME_PROCESS)) {
+ qemuCapsGet(caps, QEMU_CAPS_NAME_PROCESS)) {
virCommandAddArgFormat(cmd, "%s,process=qemu:%s",
def->name, def->name);
} else {
@@ -4439,7 +4439,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (def->os.machine)
virCommandAddArgList(cmd, "-M", def->os.machine, NULL);
- if (qemuBuildCpuArgStr(driver, def, emulator, qemuCaps,
+ if (qemuBuildCpuArgStr(driver, def, emulator, caps,
&ut, &cpu, &hasHwVirt, !!migrateFrom) < 0)
goto error;
@@ -4447,7 +4447,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArgList(cmd, "-cpu", cpu, NULL);
VIR_FREE(cpu);
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NESTING) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_NESTING) &&
hasHwVirt)
virCommandAddArg(cmd, "-enable-nesting");
}
@@ -4485,7 +4485,7 @@ qemuBuildCommandLine(virConnectPtr conn,
"%s", _("hugepages are disabled by administrator config"));
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MEM_PATH)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MEM_PATH)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("hugepage backing not supported by '%s'"),
def->emulator);
@@ -4496,7 +4496,7 @@ qemuBuildCommandLine(virConnectPtr conn,
}
virCommandAddArg(cmd, "-smp");
- if (!(smp = qemuBuildSmpArgStr(def, qemuCaps)))
+ if (!(smp = qemuBuildSmpArgStr(def, caps)))
goto error;
virCommandAddArg(cmd, smp);
VIR_FREE(smp);
@@ -4505,15 +4505,15 @@ qemuBuildCommandLine(virConnectPtr conn,
if (qemuBuildNumaArgStr(def, cmd) < 0)
goto error;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_UUID))
+ if (qemuCapsGet(caps, QEMU_CAPS_UUID))
virCommandAddArgList(cmd, "-uuid", uuid, NULL);
if (def->virtType == VIR_DOMAIN_VIRT_XEN ||
STREQ(def->os.type, "xen") ||
STREQ(def->os.type, "linux")) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DOMID)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DOMID)) {
virCommandAddArg(cmd, "-domid");
virCommandAddArgFormat(cmd, "%d", def->id);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_XEN_DOMID)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_XEN_DOMID)) {
virCommandAddArg(cmd, "-xen-attach");
virCommandAddArg(cmd, "-xen-domid");
virCommandAddArgFormat(cmd, "%d", def->id);
@@ -4530,7 +4530,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virSysinfoDefPtr source = NULL;
bool skip_uuid = false;
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SMBIOS_TYPE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support smbios settings"),
emulator);
@@ -4583,23 +4583,23 @@ qemuBuildCommandLine(virConnectPtr conn,
if (!def->graphics)
virCommandAddArg(cmd, "-nographic");
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
/* Disable global config files and default devices */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG))
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_USER_CONFIG))
virCommandAddArg(cmd, "-no-user-config");
- else if (qemuCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
+ else if (qemuCapsGet(caps, QEMU_CAPS_NODEFCONFIG))
virCommandAddArg(cmd, "-nodefconfig");
virCommandAddArg(cmd, "-nodefaults");
}
/* Serial graphics adapter */
if (def->os.bios.useserial == VIR_DOMAIN_BIOS_USESERIAL_YES) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("qemu does not support -device"));
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SGA)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SGA)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("qemu does not support SGA"));
goto error;
@@ -4615,11 +4615,11 @@ qemuBuildCommandLine(virConnectPtr conn,
if (monitor_chr) {
char *chrdev;
/* Use -chardev if it's available */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV)) {
virCommandAddArg(cmd, "-chardev");
if (!(chrdev = qemuBuildChrChardevStr(monitor_chr, "monitor",
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, chrdev);
VIR_FREE(chrdev);
@@ -4641,7 +4641,7 @@ qemuBuildCommandLine(virConnectPtr conn,
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_RTC)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_RTC)) {
const char *rtcopt;
virCommandAddArg(cmd, "-rtc");
if (!(rtcopt = qemuBuildClockArgStr(&def->clock)))
@@ -4689,7 +4689,7 @@ qemuBuildCommandLine(virConnectPtr conn,
/* This has already been taken care of (in qemuBuildClockArgStr)
if QEMU_CAPS_RTC is set (mutually exclusive with
QEMUD_FLAG_RTC_TD_HACK) */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_RTC_TD_HACK)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_RTC_TD_HACK)) {
switch (def->clock.timers[i]->tickpolicy) {
case -1:
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
@@ -4705,7 +4705,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
goto error;
}
- } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_RTC)
+ } else if (!qemuCapsGet(caps, QEMU_CAPS_RTC)
&& (def->clock.timers[i]->tickpolicy
!= VIR_DOMAIN_TIMER_TICKPOLICY_DELAY)
&& (def->clock.timers[i]->tickpolicy != -1)) {
@@ -4724,13 +4724,13 @@ qemuBuildCommandLine(virConnectPtr conn,
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
/* delay is the default if we don't have kernel
(-no-kvm-pit), otherwise, the default is catchup. */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT))
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_KVM_PIT))
virCommandAddArg(cmd, "-no-kvm-pit-reinjection");
break;
case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_KVM_PIT)) {
/* do nothing - this is default for kvm-pit */
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_TDF)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_TDF)) {
/* -tdf switches to 'catchup' with userspace pit. */
virCommandAddArg(cmd, "-tdf");
} else {
@@ -4759,7 +4759,7 @@ qemuBuildCommandLine(virConnectPtr conn,
* and when -no-hpet doesn't exist is "no". "confusing"?
* "yes"! */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_HPET)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_HPET)) {
if (def->clock.timers[i]->present == 0)
virCommandAddArg(cmd, "-no-hpet");
} else {
@@ -4774,7 +4774,7 @@ qemuBuildCommandLine(virConnectPtr conn,
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_REBOOT) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_REBOOT) &&
def->onReboot != VIR_DOMAIN_LIFECYCLE_RESTART)
virCommandAddArg(cmd, "-no-reboot");
@@ -4782,16 +4782,16 @@ qemuBuildCommandLine(virConnectPtr conn,
* when QEMU stops. If we use no-shutdown, then we can
* watch for this event and do a soft/warm reboot.
*/
- if (monitor_json && qemuCapsGet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN))
+ if (monitor_json && qemuCapsGet(caps, QEMU_CAPS_NO_SHUTDOWN))
virCommandAddArg(cmd, "-no-shutdown");
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_ACPI)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_ACPI)) {
if (!(def->features & (1 << VIR_DOMAIN_FEATURE_ACPI)))
virCommandAddArg(cmd, "-no-acpi");
}
if (def->pm.s3) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DISABLE_S3)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DISABLE_S3)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("setting ACPI S3 not supported"));
goto error;
@@ -4802,7 +4802,7 @@ qemuBuildCommandLine(virConnectPtr conn,
}
if (def->pm.s4) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DISABLE_S4)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DISABLE_S4)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("setting ACPI S4 not supported"));
goto error;
@@ -4822,15 +4822,15 @@ qemuBuildCommandLine(virConnectPtr conn,
/* def->os.nBootDevs is guaranteed to be > 0 unless per-device boot
* configuration is used
*/
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("hypervisor lacks deviceboot feature"));
goto error;
}
emitBootindex = true;
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX) &&
+ } else if (qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX) &&
(def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_ENABLED ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU))) {
+ !qemuCapsGet(caps, QEMU_CAPS_BOOT_MENU))) {
emitBootindex = true;
}
@@ -4861,7 +4861,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-boot");
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_BOOT_MENU) &&
def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_DEFAULT) {
if (def->os.bootmenu == VIR_DOMAIN_BOOT_MENU_ENABLED)
virBufferAsprintf(&boot_buf, "order=%s,menu=on", boot);
@@ -4896,7 +4896,7 @@ qemuBuildCommandLine(virConnectPtr conn,
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
for (i = 0 ; i < def->ncontrollers ; i++) {
virDomainControllerDefPtr cont = def->controllers[i];
@@ -4916,7 +4916,7 @@ qemuBuildCommandLine(virConnectPtr conn,
/* Only recent QEMU implements a SATA (AHCI) controller */
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_ICH9_AHCI)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_ICH9_AHCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("SATA is not supported with this "
"QEMU binary"));
@@ -4926,7 +4926,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildControllerDevStr(def, cont,
- qemuCaps, NULL)))
+ caps, NULL)))
goto error;
virCommandAddArg(cmd, devstr);
@@ -4934,7 +4934,7 @@ qemuBuildCommandLine(virConnectPtr conn,
}
} else if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
cont->model == -1 &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI)) {
+ !qemuCapsGet(caps, QEMU_CAPS_PIIX3_USB_UHCI)) {
if (usblegacy) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Multiple legacy USB controllers are "
@@ -4946,7 +4946,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-device");
char *devstr;
- if (!(devstr = qemuBuildControllerDevStr(def, cont, qemuCaps,
+ if (!(devstr = qemuBuildControllerDevStr(def, cont, caps,
&usbcontroller)))
goto error;
@@ -4957,10 +4957,10 @@ qemuBuildCommandLine(virConnectPtr conn,
}
/* If QEMU supports -drive param instead of old -hda, -hdb, -cdrom .. */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE)) {
int bootCD = 0, bootFloppy = 0, bootDisk = 0;
- if ((qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) || emitBootindex)) {
+ if ((qemuCapsGet(caps, QEMU_CAPS_DRIVE_BOOT) || emitBootindex)) {
/* bootDevs will get translated into either bootindex=N or boot=on
* depending on what qemu supports */
for (i = 0 ; i < def->os.nBootDevs ; i++) {
@@ -4988,7 +4988,7 @@ qemuBuildCommandLine(virConnectPtr conn,
/* Unless we have -device, then USB disks need special
handling */
if ((disk->bus == VIR_DOMAIN_DISK_BUS_USB) &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ !qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virCommandAddArg(cmd, "-usbdevice");
virCommandAddArgFormat(cmd, "disk:%s", disk->src);
@@ -5024,19 +5024,19 @@ qemuBuildCommandLine(virConnectPtr conn,
devices. Fortunately, those don't need
static PCI addresses, so we don't really
care that we can't use -device */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (disk->bus != VIR_DOMAIN_DISK_BUS_XEN) {
withDeviceArg = 1;
} else {
- qemuCapsClear(qemuCaps, QEMU_CAPS_DEVICE);
+ qemuCapsClear(caps, QEMU_CAPS_DEVICE);
deviceFlagMasked = true;
}
}
optstr = qemuBuildDriveStr(conn, disk,
emitBootindex ? false : !!bootindex,
- qemuCaps);
+ caps);
if (deviceFlagMasked)
- qemuCapsSet(qemuCaps, QEMU_CAPS_DEVICE);
+ qemuCapsSet(caps, QEMU_CAPS_DEVICE);
if (!optstr)
goto error;
virCommandAddArg(cmd, optstr);
@@ -5066,7 +5066,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-device");
if (!(optstr = qemuBuildDriveDevStr(def, disk, bootindex,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
@@ -5198,19 +5198,19 @@ qemuBuildCommandLine(virConnectPtr conn,
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_FSDEV)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_FSDEV)) {
for (i = 0 ; i < def->nfss ; i++) {
char *optstr;
virDomainFSDefPtr fs = def->fss[i];
virCommandAddArg(cmd, "-fsdev");
- if (!(optstr = qemuBuildFSStr(fs, qemuCaps)))
+ if (!(optstr = qemuBuildFSStr(fs, caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
virCommandAddArg(cmd, "-device");
- if (!(optstr = qemuBuildFSDevStr(fs, qemuCaps)))
+ if (!(optstr = qemuBuildFSDevStr(fs, caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
@@ -5225,7 +5225,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (!def->nnets) {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-net", "none", NULL);
} else {
int bootNet = 0;
@@ -5256,8 +5256,8 @@ qemuBuildCommandLine(virConnectPtr conn,
bootindex = net->info.bootIndex;
/* VLANs are not used with -netdev, so don't record them */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE))
vlan = -1;
else
vlan = i;
@@ -5318,9 +5318,9 @@ qemuBuildCommandLine(virConnectPtr conn,
*/
if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
driver->privileged ||
- (!qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE))) {
+ (!qemuCapsGet(caps, QEMU_CAPS_NETDEV_BRIDGE))) {
int tapfd = qemuNetworkIfaceConnect(def, conn, driver, net,
- qemuCaps);
+ caps);
if (tapfd < 0)
goto error;
@@ -5333,7 +5333,7 @@ qemuBuildCommandLine(virConnectPtr conn,
}
} else if (actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
int tapfd = qemuPhysIfaceConnect(def, driver, net,
- qemuCaps, vmop);
+ caps, vmop);
if (tapfd < 0)
goto error;
@@ -5352,7 +5352,7 @@ qemuBuildCommandLine(virConnectPtr conn,
network device */
int vhostfd;
- if (qemuOpenVhostNet(def, net, qemuCaps, &vhostfd) < 0)
+ if (qemuOpenVhostNet(def, net, caps, &vhostfd) < 0)
goto error;
if (vhostfd >= 0) {
virCommandTransferFD(cmd, vhostfd);
@@ -5370,19 +5370,19 @@ qemuBuildCommandLine(virConnectPtr conn,
*
* NB, no support for -netdev without use of -device
*/
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-netdev");
- if (!(host = qemuBuildHostNetStr(net, driver, qemuCaps,
+ if (!(host = qemuBuildHostNetStr(net, driver, caps,
',', vlan, tapfd_name,
vhostfd_name)))
goto error;
virCommandAddArg(cmd, host);
VIR_FREE(host);
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-device");
- nic = qemuBuildNicDevStr(net, vlan, bootindex, qemuCaps);
+ nic = qemuBuildNicDevStr(net, vlan, bootindex, caps);
if (!nic)
goto error;
virCommandAddArg(cmd, nic);
@@ -5394,10 +5394,10 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, nic);
VIR_FREE(nic);
}
- if (!(qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))) {
+ if (!(qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE))) {
virCommandAddArg(cmd, "-net");
- if (!(host = qemuBuildHostNetStr(net, driver, qemuCaps,
+ if (!(host = qemuBuildHostNetStr(net, driver, caps,
',', vlan, tapfd_name,
vhostfd_name)))
goto error;
@@ -5429,8 +5429,8 @@ qemuBuildCommandLine(virConnectPtr conn,
switch (smartcard->type) {
case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
+ !qemuCapsGet(caps, QEMU_CAPS_CCID_EMULATED)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard host "
"mode support"));
@@ -5441,8 +5441,8 @@ qemuBuildCommandLine(virConnectPtr conn,
break;
case VIR_DOMAIN_SMARTCARD_TYPE_HOST_CERTIFICATES:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
+ !qemuCapsGet(caps, QEMU_CAPS_CCID_EMULATED)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard host "
"mode support"));
@@ -5477,8 +5477,8 @@ qemuBuildCommandLine(virConnectPtr conn,
break;
case VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_PASSTHRU)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
+ !qemuCapsGet(caps, QEMU_CAPS_CCID_PASSTHRU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard "
"passthrough mode support"));
@@ -5488,7 +5488,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&smartcard->data.passthru,
smartcard->info.alias,
- qemuCaps))) {
+ caps))) {
virBufferFreeAndReset(&opt);
goto error;
}
@@ -5513,7 +5513,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (!def->nserials) {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-serial", "none", NULL);
} else {
for (i = 0 ; i < def->nserials ; i++) {
@@ -5521,18 +5521,18 @@ qemuBuildCommandLine(virConnectPtr conn,
char *devstr;
/* Use -chardev with -device if they are available */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&serial->source,
serial->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildChrDeviceStr(serial, qemuCaps,
+ if (!(devstr = qemuBuildChrDeviceStr(serial, caps,
def->os.arch,
def->os.machine)))
goto error;
@@ -5550,7 +5550,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (!def->nparallels) {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-parallel", "none", NULL);
} else {
for (i = 0 ; i < def->nparallels ; i++) {
@@ -5558,12 +5558,12 @@ qemuBuildCommandLine(virConnectPtr conn,
char *devstr;
/* Use -chardev with -device if they are available */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(¶llel->source,
parallel->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
@@ -5590,8 +5590,8 @@ qemuBuildCommandLine(virConnectPtr conn,
switch(channel->targetType) {
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
+ !qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("guestfwd requires QEMU to support -chardev & -device"));
goto error;
@@ -5600,7 +5600,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&channel->source,
channel->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
@@ -5619,13 +5619,13 @@ qemuBuildCommandLine(virConnectPtr conn,
break;
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio channel requires QEMU to support -device"));
goto error;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE_SPICEVMC) &&
channel->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) {
/* spicevmc was originally introduced via a -device
* with a backend internal to qemu; although we prefer
@@ -5635,7 +5635,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&channel->source,
channel->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
@@ -5643,7 +5643,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildVirtioSerialPortDevStr(channel,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
@@ -5658,7 +5658,7 @@ qemuBuildCommandLine(virConnectPtr conn,
switch(console->targetType) {
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio channel requires QEMU to support -device"));
goto error;
@@ -5667,14 +5667,14 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&console->source,
console->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildVirtioSerialPortDevStr(console,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
@@ -5699,7 +5699,7 @@ qemuBuildCommandLine(virConnectPtr conn,
char *optstr;
virCommandAddArg(cmd, "-device");
- if (!(optstr = qemuBuildHubDevStr(hub, qemuCaps)))
+ if (!(optstr = qemuBuildHubDevStr(hub, caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
@@ -5709,10 +5709,10 @@ qemuBuildCommandLine(virConnectPtr conn,
virDomainInputDefPtr input = def->inputs[i];
if (input->bus == VIR_DOMAIN_INPUT_BUS_USB) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
char *optstr;
virCommandAddArg(cmd, "-device");
- if (!(optstr = qemuBuildUSBInputDevStr(input, qemuCaps)))
+ if (!(optstr = qemuBuildUSBInputDevStr(input, caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
@@ -5746,7 +5746,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virBufferAsprintf(&opt, "unix:%s",
def->graphics[0]->data.vnc.socket);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_VNC_COLON)) {
const char *listenNetwork;
const char *listenAddr = NULL;
char *netAddr = NULL;
@@ -5801,7 +5801,7 @@ qemuBuildCommandLine(virConnectPtr conn,
def->graphics[0]->data.vnc.port - 5900);
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VNC_COLON)) {
if (def->graphics[0]->data.vnc.auth.passwd ||
driver->vncPassword)
virBufferAddLit(&opt, ",password");
@@ -5846,8 +5846,8 @@ qemuBuildCommandLine(virConnectPtr conn,
}
} else if ((def->ngraphics == 1) &&
def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_0_10) &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_SDL)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_0_10) &&
+ !qemuCapsGet(caps, QEMU_CAPS_SDL)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("sdl not supported by '%s'"),
def->emulator);
@@ -5873,7 +5873,7 @@ qemuBuildCommandLine(virConnectPtr conn,
/* New QEMU has this flag to let us explicitly ask for
* SDL graphics. This is better than relying on the
* default, since the default changes :-( */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_SDL))
+ if (qemuCapsGet(caps, QEMU_CAPS_SDL))
virCommandAddArg(cmd, "-sdl");
} else if ((def->ngraphics == 1) &&
@@ -5885,7 +5885,7 @@ qemuBuildCommandLine(virConnectPtr conn,
int ret;
int defaultMode = def->graphics[0]->data.spice.defaultMode;
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SPICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SPICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("spice graphics are not supported with this QEMU"));
goto error;
@@ -6033,12 +6033,12 @@ qemuBuildCommandLine(virConnectPtr conn,
}
if (def->nvideos > 0) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VGA)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VGA)) {
if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_XEN) {
/* nothing - vga has no effect on Xen pvfb */
} else {
if ((def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL) &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_VGA_QXL)) {
+ !qemuCapsGet(caps, QEMU_CAPS_VGA_QXL)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU does not support QXL graphics adapters"));
goto error;
@@ -6056,7 +6056,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL) {
if (def->videos[0]->vram &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (def->videos[0]->vram > (UINT_MAX / 1024)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("value for 'vram' must be less than '%u'"),
@@ -6066,7 +6066,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-global");
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA))
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE_QXL_VGA))
virCommandAddArgFormat(cmd, "qxl-vga.vram_size=%u",
def->videos[0]->vram * 1024);
else
@@ -6100,7 +6100,7 @@ qemuBuildCommandLine(virConnectPtr conn,
}
if (def->nvideos > 1) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
for (i = 1 ; i < def->nvideos ; i++) {
char *str;
if (def->videos[i]->type != VIR_DOMAIN_VIDEO_TYPE_QXL) {
@@ -6112,7 +6112,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-device");
- if (!(str = qemuBuildVideoDevStr(def->videos[i], qemuCaps)))
+ if (!(str = qemuBuildVideoDevStr(def->videos[i], caps)))
goto error;
virCommandAddArg(cmd, str);
@@ -6127,15 +6127,15 @@ qemuBuildCommandLine(virConnectPtr conn,
} else {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_VGA) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_VGA_NONE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE) &&
+ qemuCapsGet(caps, QEMU_CAPS_VGA) &&
+ qemuCapsGet(caps, QEMU_CAPS_VGA_NONE))
virCommandAddArgList(cmd, "-vga", "none", NULL);
}
/* Add sound hardware */
if (def->nsounds) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
for (i = 0 ; i < def->nsounds ; i++) {
virDomainSoundDefPtr sound = def->sounds[i];
char *str = NULL;
@@ -6147,7 +6147,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArgList(cmd, "-soundhw", "pcspk", NULL);
} else {
virCommandAddArg(cmd, "-device");
- if (!(str = qemuBuildSoundDevStr(sound, qemuCaps)))
+ if (!(str = qemuBuildSoundDevStr(sound, caps)))
goto error;
virCommandAddArg(cmd, str);
@@ -6158,7 +6158,7 @@ qemuBuildCommandLine(virConnectPtr conn,
for (ii = 0 ; ii < sound->ncodecs ; ii++) {
virCommandAddArg(cmd, "-device");
- if (!(codecstr = qemuBuildSoundCodecStr(sound, sound->codecs[ii], qemuCaps))) {
+ if (!(codecstr = qemuBuildSoundCodecStr(sound, sound->codecs[ii], caps))) {
goto error;
}
@@ -6171,7 +6171,7 @@ qemuBuildCommandLine(virConnectPtr conn,
0
};
virCommandAddArg(cmd, "-device");
- if (!(codecstr = qemuBuildSoundCodecStr(sound, &codec, qemuCaps))) {
+ if (!(codecstr = qemuBuildSoundCodecStr(sound, &codec, caps))) {
goto error;
}
@@ -6221,10 +6221,10 @@ qemuBuildCommandLine(virConnectPtr conn,
virDomainWatchdogDefPtr watchdog = def->watchdog;
char *optstr;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-device");
- optstr = qemuBuildWatchdogDevStr(watchdog, qemuCaps);
+ optstr = qemuBuildWatchdogDevStr(watchdog, caps);
if (!optstr)
goto error;
} else {
@@ -6263,18 +6263,18 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&redirdev->source.chr,
redirdev->info.alias,
- qemuCaps))) {
+ caps))) {
goto error;
}
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
goto error;
virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildRedirdevDevStr(redirdev, qemuCaps)))
+ if (!(devstr = qemuBuildRedirdevDevStr(redirdev, caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
@@ -6293,7 +6293,7 @@ qemuBuildCommandLine(virConnectPtr conn,
_("booting from assigned devices is only"
" supported for PCI devices"));
goto error;
- } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_BOOTINDEX)) {
+ } else if (!qemuCapsGet(caps, QEMU_CAPS_PCI_BOOTINDEX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("booting from assigned PCI devices is not"
" supported with this version of qemu"));
@@ -6305,9 +6305,9 @@ qemuBuildCommandLine(virConnectPtr conn,
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, qemuCaps)))
+ if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
@@ -6323,9 +6323,9 @@ qemuBuildCommandLine(virConnectPtr conn,
/* PCI */
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
char *configfd_name = NULL;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_PCI_CONFIGFD)) {
int configfd = qemuOpenPCIConfig(hostdev);
if (configfd >= 0) {
@@ -6338,13 +6338,13 @@ qemuBuildCommandLine(virConnectPtr conn,
}
}
virCommandAddArg(cmd, "-device");
- devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name, qemuCaps);
+ devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name, caps);
VIR_FREE(configfd_name);
if (!devstr)
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCIDEVICE)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_PCIDEVICE)) {
virCommandAddArg(cmd, "-pcidevice");
if (!(devstr = qemuBuildPCIHostdevPCIDevStr(hostdev)))
goto error;
@@ -6364,7 +6364,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (migrateFrom) {
virCommandAddArg(cmd, "-incoming");
if (STRPREFIX(migrateFrom, "tcp")) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("TCP migration is not supported with "
"this QEMU binary"));
@@ -6372,13 +6372,13 @@ qemuBuildCommandLine(virConnectPtr conn,
}
virCommandAddArg(cmd, migrateFrom);
} else if (STREQ(migrateFrom, "stdio")) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
virCommandAddArgFormat(cmd, "fd:%d", migrateFd);
virCommandPreserveFD(cmd, migrateFd);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virCommandAddArg(cmd, "exec:cat");
virCommandSetInputFD(cmd, migrateFd);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_KVM_STDIO)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_MIGRATE_KVM_STDIO)) {
virCommandAddArg(cmd, migrateFrom);
virCommandSetInputFD(cmd, migrateFd);
} else {
@@ -6388,7 +6388,7 @@ qemuBuildCommandLine(virConnectPtr conn,
goto error;
}
} else if (STRPREFIX(migrateFrom, "exec")) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("EXEC migration is not supported "
"with this QEMU binary"));
@@ -6396,7 +6396,7 @@ qemuBuildCommandLine(virConnectPtr conn,
}
virCommandAddArg(cmd, migrateFrom);
} else if (STRPREFIX(migrateFrom, "fd")) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("FD migration is not supported "
"with this QEMU binary"));
@@ -6405,7 +6405,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, migrateFrom);
virCommandPreserveFD(cmd, migrateFd);
} else if (STRPREFIX(migrateFrom, "unix")) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("UNIX migration is not supported "
"with this QEMU binary"));
@@ -6433,16 +6433,16 @@ qemuBuildCommandLine(virConnectPtr conn,
virDomainMemballoonModelTypeToString(def->memballoon->model));
goto error;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
char *optstr;
virCommandAddArg(cmd, "-device");
- optstr = qemuBuildMemballoonDevStr(def->memballoon, qemuCaps);
+ optstr = qemuBuildMemballoonDevStr(def->memballoon, caps);
if (!optstr)
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_BALLOON)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_BALLOON)) {
virCommandAddArgList(cmd, "-balloon", "virtio", NULL);
}
}
@@ -6479,7 +6479,7 @@ qemuBuildCommandLine(virConnectPtr conn,
*/
char *
qemuBuildChrDeviceStr(virDomainChrDefPtr serial,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
char *os_arch,
char *machine)
{
@@ -6491,7 +6491,7 @@ qemuBuildChrDeviceStr(virDomainChrDefPtr serial,
serial->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO) {
virBufferAsprintf(&cmd, "spapr-vty,chardev=char%s",
serial->info.alias);
- if (qemuBuildDeviceAddressStr(&cmd, &serial->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&cmd, &serial->info, caps) < 0)
goto error;
}
} else
diff --git a/src/qemu/qemu_command.h b/src/qemu/qemu_command.h
index 7c5e8dd..e155583 100644
--- a/src/qemu/qemu_command.h
+++ b/src/qemu/qemu_command.h
@@ -29,6 +29,7 @@
# include "capabilities.h"
# include "qemu_conf.h"
# include "qemu_domain.h"
+# include "qemu_capabilities.h"
/* Config type for XML import/export conversions */
# define QEMU_CONFIG_FORMAT_ARGV "qemu-argv"
@@ -53,7 +54,7 @@ virCommandPtr qemuBuildCommandLine(virConnectPtr conn,
virDomainDefPtr def,
virDomainChrSourceDefPtr monitor_chr,
bool monitor_json,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const char *migrateFrom,
int migrateFd,
virDomainSnapshotObjPtr current_snapshot,
@@ -63,14 +64,14 @@ virCommandPtr qemuBuildCommandLine(virConnectPtr conn,
/* Generate string for arch-specific '-device' parameter */
char *
qemuBuildChrDeviceStr (virDomainChrDefPtr serial,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
char *os_arch,
char *machine);
/* With vlan == -1, use netdev syntax, else old hostnet */
char * qemuBuildHostNetStr(virDomainNetDefPtr net,
struct qemud_driver *driver,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
char type_sep,
int vlan,
const char *tapfd,
@@ -85,50 +86,50 @@ char * qemuBuildNicStr(virDomainNetDefPtr net,
char * qemuBuildNicDevStr(virDomainNetDefPtr net,
int vlan,
int bootindex,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
/* Both legacy & current support */
char *qemuBuildDriveStr(virConnectPtr conn,
virDomainDiskDefPtr disk,
bool bootable,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char *qemuBuildFSStr(virDomainFSDefPtr fs,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
/* Current, best practice */
char * qemuBuildDriveDevStr(virDomainDefPtr def,
virDomainDiskDefPtr disk,
int bootindex,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char * qemuBuildFSDevStr(virDomainFSDefPtr fs,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
/* Current, best practice */
char * qemuBuildControllerDevStr(virDomainDefPtr domainDef,
virDomainControllerDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *nusbcontroller);
char * qemuBuildWatchdogDevStr(virDomainWatchdogDefPtr dev,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char * qemuBuildMemballoonDevStr(virDomainMemballoonDefPtr dev,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char * qemuBuildUSBInputDevStr(virDomainInputDefPtr dev,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char * qemuBuildSoundDevStr(virDomainSoundDefPtr sound,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
/* Legacy, pre device support */
char * qemuBuildPCIHostdevPCIDevStr(virDomainHostdevDefPtr dev);
/* Current, best practice */
char * qemuBuildPCIHostdevDevStr(virDomainHostdevDefPtr dev,
const char *configfd,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuOpenPCIConfig(virDomainHostdevDefPtr dev);
@@ -136,28 +137,28 @@ int qemuOpenPCIConfig(virDomainHostdevDefPtr dev);
char * qemuBuildUSBHostdevUsbDevStr(virDomainHostdevDefPtr dev);
/* Current, best practice */
char * qemuBuildUSBHostdevDevStr(virDomainHostdevDefPtr dev,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
-char * qemuBuildHubDevStr(virDomainHubDefPtr dev, virBitmapPtr qemuCaps);
-char * qemuBuildRedirdevDevStr(virDomainRedirdevDefPtr dev, virBitmapPtr qemuCaps);
+char * qemuBuildHubDevStr(virDomainHubDefPtr dev, qemuCapsPtr caps);
+char * qemuBuildRedirdevDevStr(virDomainRedirdevDefPtr dev, qemuCapsPtr caps);
int qemuNetworkIfaceConnect(virDomainDefPtr def,
virConnectPtr conn,
struct qemud_driver *driver,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
ATTRIBUTE_NONNULL(2);
int qemuPhysIfaceConnect(virDomainDefPtr def,
struct qemud_driver *driver,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
enum virNetDevVPortProfileOp vmop);
int qemuOpenVhostNet(virDomainDefPtr def,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *vhostfd);
int qemudCanonicalizeMachine(struct qemud_driver *driver,
@@ -185,13 +186,13 @@ virDomainDefPtr qemuParseCommandLinePid(virCapsPtr caps,
bool *monJSON);
int qemuDomainAssignAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virDomainObjPtr);
int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuDomainAssignPCIAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virDomainObjPtr obj);
qemuDomainPCIAddressSetPtr qemuDomainPCIAddressSetCreate(virDomainDefPtr def);
int qemuDomainPCIAddressReserveFunction(qemuDomainPCIAddressSetPtr addrs,
@@ -213,12 +214,12 @@ int qemuDomainPCIAddressReleaseSlot(qemuDomainPCIAddressSetPtr addrs, int slot);
void qemuDomainPCIAddressSetFree(qemuDomainPCIAddressSetPtr addrs);
int qemuAssignDevicePCISlots(virDomainDefPtr def, qemuDomainPCIAddressSetPtr addrs);
-int qemuAssignDeviceAliases(virDomainDefPtr def, virBitmapPtr qemuCaps);
+int qemuAssignDeviceAliases(virDomainDefPtr def, qemuCapsPtr caps);
int qemuDomainNetVLAN(virDomainNetDefPtr def);
int qemuAssignDeviceNetAlias(virDomainDefPtr def, virDomainNetDefPtr net, int idx);
int qemuAssignDeviceDiskAlias(virDomainDefPtr vmdef,
virDomainDiskDefPtr def,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuAssignDeviceHostdevAlias(virDomainDefPtr def, virDomainHostdevDefPtr hostdev, int idx);
int qemuAssignDeviceControllerAlias(virDomainControllerDefPtr controller);
int qemuAssignDeviceRedirdevAlias(virDomainDefPtr def, virDomainRedirdevDefPtr redirdev, int idx);
diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index 0ae30b7..44124f4 100644
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -230,7 +230,7 @@ static void qemuDomainObjPrivateFree(void *data)
{
qemuDomainObjPrivatePtr priv = data;
- qemuCapsFree(priv->qemuCaps);
+ virObjectUnref(priv->caps);
qemuDomainPCIAddressSetFree(priv->pciaddrs);
virDomainChrSourceDefFree(priv->monConfig);
@@ -290,11 +290,11 @@ static int qemuDomainObjPrivateXMLFormat(virBufferPtr buf, void *data)
virBufferAddLit(buf, " </vcpus>\n");
}
- if (priv->qemuCaps) {
+ if (priv->caps) {
int i;
virBufferAddLit(buf, " <qemuCaps>\n");
for (i = 0 ; i < QEMU_CAPS_LAST ; i++) {
- if (qemuCapsGet(priv->qemuCaps, i)) {
+ if (qemuCapsGet(priv->caps, i)) {
virBufferAsprintf(buf, " <flag name='%s'/>\n",
qemuCapsTypeToString(i));
}
@@ -335,7 +335,7 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
char *tmp;
int n, i;
xmlNodePtr *nodes = NULL;
- virBitmapPtr qemuCaps = NULL;
+ qemuCapsPtr caps = NULL;
if (VIR_ALLOC(priv->monConfig) < 0) {
virReportOOMError();
@@ -407,7 +407,7 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
goto error;
}
if (n > 0) {
- if (!(qemuCaps = qemuCapsNew()))
+ if (!(caps = qemuCapsNew()))
goto error;
for (i = 0 ; i < n ; i++) {
@@ -421,11 +421,11 @@ static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
goto error;
}
VIR_FREE(str);
- qemuCapsSet(qemuCaps, flag);
+ qemuCapsSet(caps, flag);
}
}
- priv->qemuCaps = qemuCaps;
+ priv->caps = caps;
}
VIR_FREE(nodes);
@@ -476,7 +476,7 @@ error:
virDomainChrSourceDefFree(priv->monConfig);
priv->monConfig = NULL;
VIR_FREE(nodes);
- qemuCapsFree(qemuCaps);
+ virObjectUnref(caps);
return -1;
}
diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h
index dff53cf..8ee2541 100644
--- a/src/qemu/qemu_domain.h
+++ b/src/qemu/qemu_domain.h
@@ -30,7 +30,7 @@
# include "qemu_monitor.h"
# include "qemu_agent.h"
# include "qemu_conf.h"
-# include "bitmap.h"
+# include "qemu_capabilities.h"
# include "virconsole.h"
# define QEMU_EXPECTED_VIRT_TYPES \
@@ -139,7 +139,7 @@ struct _qemuDomainObjPrivate {
qemuDomainPCIAddressSetPtr pciaddrs;
int persistentAddrs;
- virBitmapPtr qemuCaps;
+ qemuCapsPtr caps;
char *lockState;
bool fakeReboot;
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 8e8e00c..affb226 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -1805,8 +1805,8 @@ qemuDomainReboot(virDomainPtr dom, unsigned int flags)
}
} else {
#if HAVE_YAJL
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON)) {
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NO_SHUTDOWN)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MONITOR_JSON)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_NO_SHUTDOWN)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Reboot is not supported with this QEMU binary"));
goto cleanup;
@@ -2328,7 +2328,7 @@ static int qemudDomainGetInfo(virDomainPtr dom,
if ((vm->def->memballoon != NULL) &&
(vm->def->memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_NONE)) {
info->memory = vm->def->mem.max_balloon;
- } else if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BALLOON_EVENT)) {
+ } else if (qemuCapsGet(priv->caps, QEMU_CAPS_BALLOON_EVENT)) {
info->memory = vm->def->mem.cur_balloon;
} else if (qemuDomainJobAllowed(priv, QEMU_JOB_QUERY)) {
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
@@ -3116,7 +3116,7 @@ static int qemuDumpToFd(struct qemud_driver *driver, virDomainObjPtr vm,
qemuDomainObjPrivatePtr priv = vm->privateData;
int ret = -1;
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DUMP_GUEST_MEMORY)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DUMP_GUEST_MEMORY)) {
virReportError(VIR_ERR_NO_SUPPORT, "%s",
_("dump-guest-memory is not supported"));
return -1;
@@ -5047,7 +5047,7 @@ static char *qemuDomainGetXMLDesc(virDomainPtr dom,
/* Refresh current memory based on balloon info if supported */
if ((vm->def->memballoon != NULL) &&
(vm->def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_NONE) &&
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BALLOON_EVENT) &&
+ !qemuCapsGet(priv->caps, QEMU_CAPS_BALLOON_EVENT) &&
(virDomainObjIsActive(vm))) {
/* Don't delay if someone's using the monitor, just use
* existing most recent data instead */
@@ -5133,7 +5133,7 @@ static char *qemuDomainXMLToNative(virConnectPtr conn,
struct qemud_driver *driver = conn->privateData;
virDomainDefPtr def = NULL;
virDomainChrSourceDef monConfig;
- virBitmapPtr qemuCaps = NULL;
+ qemuCapsPtr caps = NULL;
bool monitor_json = false;
virCommandPtr cmd = NULL;
char *ret = NULL;
@@ -5225,19 +5225,19 @@ static char *qemuDomainXMLToNative(virConnectPtr conn,
if (qemuCapsExtractVersionInfo(def->emulator, def->os.arch,
false,
NULL,
- &qemuCaps) < 0)
+ &caps) < 0)
goto cleanup;
- monitor_json = qemuCapsGet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
+ monitor_json = qemuCapsGet(caps, QEMU_CAPS_MONITOR_JSON);
if (qemuProcessPrepareMonitorChr(driver, &monConfig, def->name) < 0)
goto cleanup;
- if (qemuAssignDeviceAliases(def, qemuCaps) < 0)
+ if (qemuAssignDeviceAliases(def, caps) < 0)
goto cleanup;
if (!(cmd = qemuBuildCommandLine(conn, driver, def,
- &monConfig, monitor_json, qemuCaps,
+ &monConfig, monitor_json, caps,
NULL, -1, NULL, VIR_NETDEV_VPORT_PROFILE_OP_NO_OP)))
goto cleanup;
@@ -5246,7 +5246,7 @@ static char *qemuDomainXMLToNative(virConnectPtr conn,
cleanup:
qemuDriverUnlock(driver);
- qemuCapsFree(qemuCaps);
+ virObjectUnref(caps);
virCommandFree(cmd);
virDomainDefFree(def);
return ret;
@@ -10580,7 +10580,7 @@ qemuDomainSnapshotDiskPrepare(virDomainObjPtr vm, virDomainSnapshotDefPtr def,
int external = 0;
qemuDomainObjPrivatePtr priv = vm->privateData;
- if (allow_reuse && !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
+ if (allow_reuse && !qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("reuse is not supported with this QEMU binary"));
goto cleanup;
@@ -10661,7 +10661,7 @@ qemuDomainSnapshotDiskPrepare(virDomainObjPtr vm, virDomainSnapshotDefPtr def,
}
if (active) {
if (external == 1 ||
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
+ qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
*flags |= VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC;
} else if (atomic && external > 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
@@ -10934,7 +10934,7 @@ qemuDomainSnapshotCreateDiskActive(virConnectPtr conn,
goto cleanup;
}
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
actions = virJSONValueNewArray();
if (!actions) {
virReportOOMError();
@@ -11034,7 +11034,7 @@ cleanup:
}
if (vm && (ret == 0 ||
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION))) {
+ !qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION))) {
if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0 ||
(persist &&
virDomainSaveConfig(driver->configDir, vm->newDef) < 0))
@@ -12616,9 +12616,9 @@ qemuDomainBlockJobImpl(virDomainPtr dom, const char *path, const char *base,
}
priv = vm->privateData;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_BLOCKJOB_ASYNC)) {
async = true;
- } else if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC)) {
+ } else if (!qemuCapsGet(priv->caps, QEMU_CAPS_BLOCKJOB_SYNC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block jobs not supported with this QEMU binary"));
goto cleanup;
@@ -12880,7 +12880,7 @@ qemuDomainSetBlockIoTune(virDomainPtr dom,
goto cleanup;
}
priv = vm->privateData;
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DRIVE_IOTUNE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block I/O throttling not supported with this "
"QEMU binary"));
@@ -13733,7 +13733,7 @@ qemuDomainPMSuspendForDuration(virDomainPtr dom,
goto cleanup;
}
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_WAKEUP) &&
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_WAKEUP) &&
(target == VIR_NODE_SUSPEND_TARGET_MEM ||
target == VIR_NODE_SUSPEND_TARGET_HYBRID)) {
virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
@@ -13829,7 +13829,7 @@ qemuDomainPMWakeup(virDomainPtr dom,
priv = vm->privateData;
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_WAKEUP)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_WAKEUP)) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("Unable to wake up domain due to "
"missing system_wakeup monitor command"));
diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c
index a8a904c..a792456 100644
--- a/src/qemu/qemu_hotplug.c
+++ b/src/qemu/qemu_hotplug.c
@@ -98,7 +98,7 @@ int qemuDomainChangeEjectableMedia(struct qemud_driver *driver,
return -1;
}
- if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, priv->qemuCaps)))
+ if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, priv->caps)))
goto error;
qemuDomainObjEnterMonitorWithDriver(driver, vm);
@@ -227,17 +227,17 @@ int qemuDomainAttachPciDiskDevice(virConnectPtr conn,
return -1;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0)
goto error;
releaseaddr = true;
- if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
+ if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->caps) < 0)
goto error;
- if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->qemuCaps)))
+ if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->caps)))
goto error;
- if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->qemuCaps)))
+ if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->caps)))
goto error;
}
@@ -247,7 +247,7 @@ int qemuDomainAttachPciDiskDevice(virConnectPtr conn,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
@@ -287,7 +287,7 @@ error:
VIR_FREE(devstr);
VIR_FREE(drivestr);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
(disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
@@ -322,7 +322,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
return -1;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0)
goto cleanup;
releaseaddr = true;
@@ -331,13 +331,13 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
controller->model == -1 &&
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI)) {
+ !qemuCapsGet(priv->caps, QEMU_CAPS_PIIX3_USB_UHCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("USB controller hotplug unsupported in this QEMU binary"));
goto cleanup;
}
- if (!(devstr = qemuBuildControllerDevStr(vm->def, controller, priv->qemuCaps, NULL))) {
+ if (!(devstr = qemuBuildControllerDevStr(vm->def, controller, priv->caps, NULL))) {
goto cleanup;
}
}
@@ -348,7 +348,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
} else {
ret = qemuMonitorAttachPCIDiskController(priv->mon,
@@ -364,7 +364,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
cleanup:
if ((ret != 0) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
(controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
@@ -461,14 +461,14 @@ int qemuDomainAttachSCSIDisk(virConnectPtr conn,
goto error;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
- if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->caps) < 0)
goto error;
- if (!(devstr = qemuBuildDriveDevStr(vm->def, disk, 0, priv->qemuCaps)))
+ if (!(devstr = qemuBuildDriveDevStr(vm->def, disk, 0, priv->caps)))
goto error;
}
- if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->qemuCaps)))
+ if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->caps)))
goto error;
for (i = 0 ; i <= disk->info.addr.drive.controller ; i++) {
@@ -494,7 +494,7 @@ int qemuDomainAttachSCSIDisk(virConnectPtr conn,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
@@ -583,12 +583,12 @@ int qemuDomainAttachUsbMassstorageDevice(virConnectPtr conn,
goto error;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
- if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->caps) < 0)
goto error;
- if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->qemuCaps)))
+ if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->caps)))
goto error;
- if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->qemuCaps)))
+ if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->caps)))
goto error;
}
@@ -598,7 +598,7 @@ int qemuDomainAttachUsbMassstorageDevice(virConnectPtr conn,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
@@ -688,7 +688,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
goto cleanup;
}
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_HOST_NET_ADD)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_HOST_NET_ADD)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("installed qemu version does not support host_net_add"));
goto cleanup;
@@ -703,38 +703,38 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
*/
if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
driver->privileged ||
- (!qemuCapsGet (priv->qemuCaps, QEMU_CAPS_NETDEV_BRIDGE))) {
+ (!qemuCapsGet (priv->caps, QEMU_CAPS_NETDEV_BRIDGE))) {
if ((tapfd = qemuNetworkIfaceConnect(vm->def, conn, driver, net,
- priv->qemuCaps)) < 0)
+ priv->caps)) < 0)
goto cleanup;
iface_connected = true;
- if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
+ if (qemuOpenVhostNet(vm->def, net, priv->caps, &vhostfd) < 0)
goto cleanup;
}
} else if (actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
if ((tapfd = qemuPhysIfaceConnect(vm->def, driver, net,
- priv->qemuCaps,
+ priv->caps,
VIR_NETDEV_VPORT_PROFILE_OP_CREATE)) < 0)
goto cleanup;
iface_connected = true;
- if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
+ if (qemuOpenVhostNet(vm->def, net, priv->caps, &vhostfd) < 0)
goto cleanup;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NET_NAME) ||
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NET_NAME) ||
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0)
goto cleanup;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0)
goto cleanup;
releaseaddr = true;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
vlan = -1;
} else {
vlan = qemuDomainNetVLAN(net);
@@ -756,22 +756,22 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
goto no_memory;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
- if (!(netstr = qemuBuildHostNetStr(net, driver, priv->qemuCaps,
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (!(netstr = qemuBuildHostNetStr(net, driver, priv->caps,
',', -1, tapfd_name,
vhostfd_name)))
goto cleanup;
} else {
- if (!(netstr = qemuBuildHostNetStr(net, driver, priv->qemuCaps,
+ if (!(netstr = qemuBuildHostNetStr(net, driver, priv->caps,
' ', vlan, tapfd_name,
vhostfd_name)))
goto cleanup;
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddNetdev(priv->mon, netstr, tapfd, tapfd_name,
vhostfd, vhostfd_name) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
@@ -797,8 +797,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
goto cleanup;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
- if (!(nicstr = qemuBuildNicDevStr(net, vlan, 0, priv->qemuCaps)))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (!(nicstr = qemuBuildNicDevStr(net, vlan, 0, priv->caps)))
goto try_remove;
} else {
if (!(nicstr = qemuBuildNicStr(net, NULL, vlan)))
@@ -806,7 +806,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
@@ -833,7 +833,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
} else {
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV)) {
if (qemuMonitorSetLink(priv->mon, net->info.alias, VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
@@ -857,7 +857,7 @@ cleanup:
if (!ret) {
vm->def->nets[vm->def->nnets++] = net;
} else {
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
(net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
@@ -890,8 +890,8 @@ try_remove:
goto cleanup;
if (vlan < 0) {
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
char *netdev_name;
if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0)
goto no_memory;
@@ -943,13 +943,13 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
&hostdev, 1) < 0)
return -1;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error;
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, hostdev->info) < 0)
goto error;
releaseaddr = true;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_PCI_CONFIGFD)) {
configfd = qemuOpenPCIConfig(hostdev);
if (configfd >= 0) {
if (virAsprintf(&configfd_name, "fd-%s",
@@ -967,7 +967,7 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
}
if (!(devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name,
- priv->qemuCaps)))
+ priv->caps)))
goto error;
qemuDomainObjEnterMonitorWithDriver(driver, vm);
@@ -999,7 +999,7 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
return 0;
error:
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
(hostdev->info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
@@ -1024,10 +1024,10 @@ int qemuDomainAttachRedirdevDevice(struct qemud_driver *driver,
qemuDomainObjPrivatePtr priv = vm->privateData;
char *devstr = NULL;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceRedirdevAlias(vm->def, redirdev, -1) < 0)
goto error;
- if (!(devstr = qemuBuildRedirdevDevStr(redirdev, priv->qemuCaps)))
+ if (!(devstr = qemuBuildRedirdevDevStr(redirdev, priv->caps)))
goto error;
}
@@ -1037,7 +1037,7 @@ int qemuDomainAttachRedirdevDevice(struct qemud_driver *driver,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE))
ret = qemuMonitorAddDevice(priv->mon, devstr);
else
goto error;
@@ -1067,10 +1067,10 @@ int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
qemuDomainObjPrivatePtr priv = vm->privateData;
char *devstr = NULL;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error;
- if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, priv->qemuCaps)))
+ if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, priv->caps)))
goto error;
}
@@ -1102,7 +1102,7 @@ int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE))
ret = qemuMonitorAddDevice(priv->mon, devstr);
else
ret = qemuMonitorAddUSBDeviceExact(priv->mon,
@@ -1696,7 +1696,7 @@ int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", false);
@@ -1718,7 +1718,7 @@ int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
virDomainAuditDisk(vm, detach->src, NULL, "detach", true);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info.addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src);
@@ -1766,7 +1766,7 @@ int qemuDomainDetachDiskDevice(struct qemud_driver *driver,
goto cleanup;
}
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("Underlying qemu does not support %s disk removal"),
virDomainDiskBusTypeToString(dev->data.disk->bus));
@@ -1921,13 +1921,13 @@ int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
goto cleanup;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceControllerAlias(detach) < 0)
goto cleanup;
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
goto cleanup;
@@ -1944,7 +1944,7 @@ int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
virDomainControllerRemove(vm->def, idx);
virDomainControllerDefFree(detach);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info.addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on controller");
@@ -1982,7 +1982,7 @@ qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorDelDevice(priv->mon, detach->info->alias);
} else {
ret = qemuMonitorRemovePCIDevice(priv->mon, &detach->info->addr.pci);
@@ -2017,7 +2017,7 @@ qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
ret = -1;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info->addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on host device");
@@ -2041,7 +2041,7 @@ qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
return -1;
}
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("device cannot be detached with this QEMU version"));
return -1;
@@ -2232,7 +2232,7 @@ qemuDomainDetachNetDevice(struct qemud_driver *driver,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
@@ -2247,8 +2247,8 @@ qemuDomainDetachNetDevice(struct qemud_driver *driver,
}
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
@@ -2265,7 +2265,7 @@ qemuDomainDetachNetDevice(struct qemud_driver *driver,
virDomainAuditNet(vm, detach, NULL, "detach", true);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info.addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on NIC");
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 1b21ef6..99fc8ce 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -1905,7 +1905,7 @@ qemuMigrationRun(struct qemud_driver *driver,
break;
case MIGRATION_DEST_UNIX:
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
ret = qemuMonitorMigrateToUnix(priv->mon, migrate_flags,
spec->dest.unix_socket.file);
} else {
@@ -2058,7 +2058,7 @@ static int doNativeMigrate(struct qemud_driver *driver,
if (!uribits)
return -1;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD))
spec.destType = MIGRATION_DEST_CONNECT_HOST;
else
spec.destType = MIGRATION_DEST_HOST;
@@ -2099,9 +2099,9 @@ static int doTunnelMigrate(struct qemud_driver *driver,
driver, vm, st, NULLSTR(cookiein), cookieinlen,
cookieout, cookieoutlen, flags, resource);
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
+ !qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
+ !qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("Source qemu is too old to support tunnelled migration"));
return -1;
@@ -2110,7 +2110,7 @@ static int doTunnelMigrate(struct qemud_driver *driver,
spec.fwdType = MIGRATION_FWD_STREAM;
spec.fwd.stream = st;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
int fds[2];
spec.destType = MIGRATION_DEST_FD;
@@ -3192,7 +3192,7 @@ qemuMigrationToFile(struct qemud_driver *driver, virDomainObjPtr vm,
qemuDomainObjExitMonitorWithDriver(driver, vm);
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
(!compressor || pipe(pipeFD) == 0)) {
/* All right! We can use fd migration, which means that qemu
* doesn't have to open() the file, so while we still have to
@@ -3243,7 +3243,7 @@ qemuMigrationToFile(struct qemud_driver *driver, virDomainObjPtr vm,
if (!compressor) {
const char *args[] = { "cat", NULL };
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
priv->monConfig->type == VIR_DOMAIN_CHR_TYPE_UNIX) {
rc = qemuMonitorMigrateToFd(priv->mon,
QEMU_MONITOR_MIGRATE_BACKGROUND,
diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index e04af72..f8d717f 100644
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -1127,7 +1127,7 @@ int qemuMonitorEmitBalloonChange(qemuMonitorPtr mon,
int qemuMonitorSetCapabilities(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
int ret;
VIR_DEBUG("mon=%p", mon);
@@ -1143,11 +1143,11 @@ int qemuMonitorSetCapabilities(qemuMonitorPtr mon,
if (ret < 0)
goto cleanup;
- ret = qemuMonitorJSONCheckCommands(mon, qemuCaps);
+ ret = qemuMonitorJSONCheckCommands(mon, caps);
if (ret < 0)
goto cleanup;
- ret = qemuMonitorJSONCheckEvents(mon, qemuCaps);
+ ret = qemuMonitorJSONCheckEvents(mon, caps);
if (ret < 0)
goto cleanup;
} else {
diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h
index 0f7ca2d..f206d49 100644
--- a/src/qemu/qemu_monitor.h
+++ b/src/qemu/qemu_monitor.h
@@ -27,6 +27,7 @@
# include "internal.h"
+# include "qemu_capabilities.h"
# include "domain_conf.h"
# include "qemu_conf.h"
# include "bitmap.h"
@@ -156,7 +157,7 @@ qemuMonitorPtr qemuMonitorOpenFD(virDomainObjPtr vm,
void qemuMonitorClose(qemuMonitorPtr mon);
int qemuMonitorSetCapabilities(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuMonitorCheckHMP(qemuMonitorPtr mon, const char *cmd);
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index 10a68c6..11b85d9 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -974,7 +974,7 @@ qemuMonitorJSONSetCapabilities(qemuMonitorPtr mon)
*/
int
qemuMonitorJSONCheckCommands(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
int ret = -1;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-commands", NULL);
@@ -1003,15 +1003,15 @@ qemuMonitorJSONCheckCommands(qemuMonitorPtr mon,
goto cleanup;
if (STREQ(name, "system_wakeup"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_WAKEUP);
+ qemuCapsSet(caps, QEMU_CAPS_WAKEUP);
else if (STREQ(name, "transaction"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_TRANSACTION);
+ qemuCapsSet(caps, QEMU_CAPS_TRANSACTION);
else if (STREQ(name, "block_job_cancel"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC);
+ qemuCapsSet(caps, QEMU_CAPS_BLOCKJOB_SYNC);
else if (STREQ(name, "block-job-cancel"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC);
+ qemuCapsSet(caps, QEMU_CAPS_BLOCKJOB_ASYNC);
else if (STREQ(name, "dump-guest-memory"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_MEMORY);
+ qemuCapsSet(caps, QEMU_CAPS_DUMP_GUEST_MEMORY);
}
ret = 0;
@@ -1025,7 +1025,7 @@ cleanup:
int
qemuMonitorJSONCheckEvents(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
int ret = -1;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-events", NULL);
@@ -1061,7 +1061,7 @@ qemuMonitorJSONCheckEvents(qemuMonitorPtr mon,
goto cleanup;
if (STREQ(name, "BALLOON_CHANGE"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_BALLOON_EVENT);
+ qemuCapsSet(caps, QEMU_CAPS_BALLOON_EVENT);
}
ret = 0;
diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h
index f6e34f4..d092b88 100644
--- a/src/qemu/qemu_monitor_json.h
+++ b/src/qemu/qemu_monitor_json.h
@@ -43,9 +43,9 @@ int qemuMonitorJSONHumanCommandWithFd(qemuMonitorPtr mon,
int qemuMonitorJSONSetCapabilities(qemuMonitorPtr mon);
int qemuMonitorJSONCheckCommands(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuMonitorJSONCheckEvents(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuMonitorJSONStartCPUs(qemuMonitorPtr mon,
virConnectPtr conn);
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index 77d679a..5ac1d2b 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -1262,7 +1262,7 @@ qemuConnectMonitor(struct qemud_driver *driver, virDomainObjPtr vm)
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- ret = qemuMonitorSetCapabilities(priv->mon, priv->qemuCaps);
+ ret = qemuMonitorSetCapabilities(priv->mon, priv->caps);
qemuDomainObjExitMonitorWithDriver(driver, vm);
error:
@@ -1472,10 +1472,10 @@ qemuProcessLookupPTYs(virDomainChrDefPtr *devices,
static int
qemuProcessFindCharDevicePTYsMonitor(virDomainObjPtr vm,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virHashTablePtr paths)
{
- bool chardevfmt = qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV);
+ bool chardevfmt = qemuCapsGet(caps, QEMU_CAPS_CHARDEV);
if (qemuProcessLookupPTYs(vm->def->serials, vm->def->nserials,
paths, chardevfmt) < 0)
@@ -1584,7 +1584,7 @@ qemuProcessReadLogFD(int logfd, char *buf, int maxlen, int off)
static int
qemuProcessWaitForMonitor(struct qemud_driver* driver,
virDomainObjPtr vm,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
off_t pos)
{
char *buf = NULL;
@@ -1629,7 +1629,7 @@ qemuProcessWaitForMonitor(struct qemud_driver* driver,
VIR_DEBUG("qemuMonitorGetPtyPaths returned %i", ret);
if (ret == 0)
- ret = qemuProcessFindCharDevicePTYsMonitor(vm, qemuCaps, paths);
+ ret = qemuProcessFindCharDevicePTYsMonitor(vm, caps, paths);
cleanup:
virHashFree(paths);
@@ -1930,7 +1930,7 @@ qemuProcessSetLinkStates(virDomainObjPtr vm)
if (def->nets[i]->linkstate == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) {
VIR_DEBUG("Setting link state: %s", def->nets[i]->info.alias);
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV)) {
virReportError(VIR_ERR_NO_SUPPORT, "%s",
_("Setting of link state is not supported by this qemu"));
return -1;
@@ -2091,7 +2091,7 @@ qemuProcessInitPasswords(virConnectPtr conn,
if (ret < 0)
goto cleanup;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
int i;
for (i = 0 ; i < vm->def->ndisks ; i++) {
@@ -3163,11 +3163,11 @@ qemuProcessReconnect(void *opaque)
/* If upgrading from old libvirtd we won't have found any
* caps in the domain status, so re-query them
*/
- if (!priv->qemuCaps &&
+ if (!priv->caps &&
qemuCapsExtractVersionInfo(obj->def->emulator, obj->def->os.arch,
false,
NULL,
- &priv->qemuCaps) < 0)
+ &priv->caps) < 0)
goto error;
/* In case the domain shutdown while we were not running,
@@ -3183,8 +3183,8 @@ qemuProcessReconnect(void *opaque)
goto endjob;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
- if ((qemuDomainAssignAddresses(obj->def, priv->qemuCaps, obj)) < 0)
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE))
+ if ((qemuDomainAssignAddresses(obj->def, priv->caps, obj)) < 0)
goto error;
if (virSecurityManagerReserveLabel(driver->securityManager, obj->def, obj->pid) < 0)
@@ -3256,7 +3256,7 @@ error:
* to remove danger of it ending up running twice if
* user tries to start it again later
*/
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NO_SHUTDOWN)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NO_SHUTDOWN)) {
/* If we couldn't get the monitor and qemu supports
* no-shutdown, we can safely say that the domain
* crashed ... */
@@ -3563,15 +3563,15 @@ int qemuProcessStart(virConnectPtr conn,
}
VIR_DEBUG("Determining emulator version");
- qemuCapsFree(priv->qemuCaps);
- priv->qemuCaps = NULL;
+ virObjectUnref(priv->caps);
+ priv->caps = NULL;
if (qemuCapsExtractVersionInfo(vm->def->emulator, vm->def->os.arch,
true,
NULL,
- &priv->qemuCaps) < 0)
+ &priv->caps) < 0)
goto cleanup;
- if (qemuAssignDeviceAliases(vm->def, priv->qemuCaps) < 0)
+ if (qemuAssignDeviceAliases(vm->def, priv->caps) < 0)
goto cleanup;
VIR_DEBUG("Checking for CDROM and floppy presence");
@@ -3616,7 +3616,7 @@ int qemuProcessStart(virConnectPtr conn,
if (qemuProcessPrepareMonitorChr(driver, priv->monConfig, vm->def->name) < 0)
goto cleanup;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MONITOR_JSON))
priv->monJSON = 1;
else
priv->monJSON = 0;
@@ -3647,15 +3647,15 @@ int qemuProcessStart(virConnectPtr conn,
* we also need to populate the PCi address set cache for later
* use in hotplug
*/
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Assigning domain PCI addresses");
- if ((qemuDomainAssignAddresses(vm->def, priv->qemuCaps, vm)) < 0)
+ if ((qemuDomainAssignAddresses(vm->def, priv->caps, vm)) < 0)
goto cleanup;
}
VIR_DEBUG("Building emulator command line");
if (!(cmd = qemuBuildCommandLine(conn, driver, vm->def, priv->monConfig,
- priv->monJSON != 0, priv->qemuCaps,
+ priv->monJSON != 0, priv->caps,
migrateFrom, stdin_fd, snapshot, vmop)))
goto cleanup;
@@ -3800,7 +3800,7 @@ int qemuProcessStart(virConnectPtr conn,
goto cleanup;
VIR_DEBUG("Waiting for monitor to show up");
- if (qemuProcessWaitForMonitor(driver, vm, priv->qemuCaps, pos) < 0)
+ if (qemuProcessWaitForMonitor(driver, vm, priv->caps, pos) < 0)
goto cleanup;
/* Failure to connect to agent shouldn't be fatal */
@@ -3837,7 +3837,7 @@ int qemuProcessStart(virConnectPtr conn,
/* If we have -device, then addresses are assigned explicitly.
* If not, then we have to detect dynamic ones here */
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Determining domain device PCI addresses");
if (qemuProcessInitPCIAddresses(driver, vm) < 0)
goto cleanup;
@@ -4222,8 +4222,8 @@ retry:
virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason);
VIR_FREE(priv->vcpupids);
priv->nvcpupids = 0;
- qemuCapsFree(priv->qemuCaps);
- priv->qemuCaps = NULL;
+ virObjectUnref(priv->caps);
+ priv->caps = NULL;
VIR_FREE(priv->pidfile);
/* The "release" hook cleans up additional resources */
@@ -4333,13 +4333,13 @@ int qemuProcessAttach(virConnectPtr conn ATTRIBUTE_UNUSED,
goto cleanup;
VIR_DEBUG("Determining emulator version");
- qemuCapsFree(priv->qemuCaps);
- priv->qemuCaps = NULL;
+ virObjectUnref(priv->caps);
+ priv->caps = NULL;
if (qemuCapsExtractVersionInfo(vm->def->emulator,
vm->def->os.arch,
false,
NULL,
- &priv->qemuCaps) < 0)
+ &priv->caps) < 0)
goto cleanup;
VIR_DEBUG("Preparing monitor state");
@@ -4356,9 +4356,9 @@ int qemuProcessAttach(virConnectPtr conn ATTRIBUTE_UNUSED,
* we also need to populate the PCi address set cache for later
* use in hotplug
*/
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Assigning domain PCI addresses");
- if ((qemuDomainAssignAddresses(vm->def, priv->qemuCaps, vm)) < 0)
+ if ((qemuDomainAssignAddresses(vm->def, priv->caps, vm)) < 0)
goto cleanup;
}
@@ -4380,7 +4380,7 @@ int qemuProcessAttach(virConnectPtr conn ATTRIBUTE_UNUSED,
vm->pid = pid;
VIR_DEBUG("Waiting for monitor to show up");
- if (qemuProcessWaitForMonitor(driver, vm, priv->qemuCaps, -1) < 0)
+ if (qemuProcessWaitForMonitor(driver, vm, priv->caps, -1) < 0)
goto cleanup;
/* Failure to connect to agent shouldn't be fatal */
@@ -4397,7 +4397,7 @@ int qemuProcessAttach(virConnectPtr conn ATTRIBUTE_UNUSED,
/* If we have -device, then addresses are assigned explicitly.
* If not, then we have to detect dynamic ones here */
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Determining domain device PCI addresses");
if (qemuProcessInitPCIAddresses(driver, vm) < 0)
goto cleanup;
diff --git a/tests/qemuhelptest.c b/tests/qemuhelptest.c
index 0d884f4..748c43f 100644
--- a/tests/qemuhelptest.c
+++ b/tests/qemuhelptest.c
@@ -11,14 +11,14 @@
struct testInfo {
const char *name;
- virBitmapPtr flags;
+ qemuCapsPtr flags;
unsigned int version;
unsigned int is_kvm;
unsigned int kvm_version;
};
-static void printMismatchedFlags(virBitmapPtr got,
- virBitmapPtr expect)
+static void printMismatchedFlags(qemuCapsPtr got,
+ qemuCapsPtr expect)
{
int i;
@@ -38,7 +38,7 @@ static int testHelpStrParsing(const void *data)
char *path = NULL;
char *help = NULL;
unsigned int version, is_kvm, kvm_version;
- virBitmapPtr flags = NULL;
+ qemuCapsPtr flags = NULL;
int ret = -1;
char *got = NULL;
char *expected = NULL;
@@ -75,8 +75,8 @@ static int testHelpStrParsing(const void *data)
goto cleanup;
}
- got = virBitmapString(flags);
- expected = virBitmapString(info->flags);
+ got = qemuCapsFlagsString(flags);
+ expected = qemuCapsFlagsString(info->flags);
if (!got || !expected)
goto cleanup;
@@ -116,7 +116,7 @@ static int testHelpStrParsing(const void *data)
cleanup:
VIR_FREE(path);
VIR_FREE(help);
- qemuCapsFree(flags);
+ virObjectUnref(flags);
VIR_FREE(got);
VIR_FREE(expected);
return ret;
@@ -138,7 +138,7 @@ mymain(void)
if (virtTestRun("QEMU Help String Parsing " name, \
1, testHelpStrParsing, &info) < 0) \
ret = -1; \
- qemuCapsFree(info.flags); \
+ virObjectUnref(info.flags); \
} while (0)
DO_TEST("qemu-0.9.1", 9001, 0, 0,
diff --git a/tests/qemuxml2argvtest.c b/tests/qemuxml2argvtest.c
index 47c3f6c..11b9aab 100644
--- a/tests/qemuxml2argvtest.c
+++ b/tests/qemuxml2argvtest.c
@@ -78,7 +78,7 @@ typedef enum {
static int testCompareXMLToArgvFiles(const char *xml,
const char *cmdline,
- virBitmapPtr extraFlags,
+ qemuCapsPtr extraFlags,
const char *migrateFrom,
int migrateFd,
virQemuXML2ArgvTestFlags flags)
@@ -235,7 +235,7 @@ out:
struct testInfo {
const char *name;
- virBitmapPtr extraFlags;
+ qemuCapsPtr extraFlags;
const char *migrateFrom;
int migrateFd;
unsigned int flags;
@@ -311,7 +311,7 @@ mymain(void)
if (virtTestRun("QEMU XML-2-ARGV " name, \
1, testCompareXMLToArgvHelper, &info) < 0) \
ret = -1; \
- qemuCapsFree(info.extraFlags); \
+ virObjectUnref(info.extraFlags); \
} while (0)
# define DO_TEST(name, ...) \
diff --git a/tests/qemuxmlnstest.c b/tests/qemuxmlnstest.c
index 253c89e..43b5fe6 100644
--- a/tests/qemuxmlnstest.c
+++ b/tests/qemuxmlnstest.c
@@ -25,7 +25,7 @@ static struct qemud_driver driver;
static int testCompareXMLToArgvFiles(const char *xml,
const char *cmdline,
- virBitmapPtr extraFlags,
+ qemuCapsPtr extraFlags,
const char *migrateFrom,
int migrateFd,
bool json,
@@ -164,7 +164,7 @@ static int testCompareXMLToArgvFiles(const char *xml,
struct testInfo {
const char *name;
- virBitmapPtr extraFlags;
+ qemuCapsPtr extraFlags;
const char *migrateFrom;
int migrateFd;
bool json;
@@ -238,7 +238,7 @@ mymain(void)
if (virtTestRun("QEMU XML-2-ARGV " name, \
1, testCompareXMLToArgvHelper, &info) < 0) \
ret = -1; \
- qemuCapsFree(info.extraFlags); \
+ virObjectUnref(info.extraFlags); \
} while (0)
# define DO_TEST(name, expectError, ...) \
--
1.7.11.4
--
libvir-list mailing list
libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list