[libvirt] [PATCH 06/20] Turn QEMU capabilities object into a full virObjectPtr

From: "Daniel P. Berrange" <berrange(a)redhat.com&gt; 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(a)redhat.com&gt; --- 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(&parallel->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