Re: [libvirt] [PATCH 2/3] Rename 'qemuCapsXXX' to 'virQEMUCapsXXX'

On Wed, Feb 06, 2013 at 04:30:18PM +0100, Jiri Denemark wrote: Hmm, yes that was an oversight. Here is a delta-patch for review. Daniel diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index 32b8ee2..4efe052 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -247,9 +247,9 @@ static void virQEMUCapsDispose(void *obj); static int virQEMUCapsOnceInit(void) { if (!(virQEMUCapsClass = virClassNew(virClassForObject(), - "virQEMUCaps", - sizeof(virQEMUCaps), - virQEMUCapsDispose))) + "virQEMUCaps", + sizeof(virQEMUCaps), + virQEMUCapsDispose))) return -1; return 0; @@ -308,15 +308,15 @@ cleanup: static virCommandPtr virQEMUCapsProbeCommand(const char *qemu, - virQEMUCapsPtr caps, + virQEMUCapsPtr qemuCaps, virQEMUCapsHookDataPtr hookData) { virCommandPtr cmd = virCommandNew(qemu); - if (caps) { - if (virQEMUCapsGet(caps, QEMU_CAPS_NO_USER_CONFIG)) + if (qemuCaps) { + if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG)) virCommandAddArg(cmd, "-no-user-config"); - else if (virQEMUCapsGet(caps, QEMU_CAPS_NODEFCONFIG)) + else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG)) virCommandAddArg(cmd, "-nodefconfig"); } @@ -329,20 +329,20 @@ virQEMUCapsProbeCommand(const char *qemu, static void -virQEMUCapsSetDefaultMachine(virQEMUCapsPtr caps, +virQEMUCapsSetDefaultMachine(virQEMUCapsPtr qemuCaps, size_t defIdx) { - char *name = caps->machineTypes[defIdx]; - char *alias = caps->machineAliases[defIdx]; - - memmove(caps->machineTypes + 1, - caps->machineTypes, - sizeof(caps->machineTypes[0]) * defIdx); - memmove(caps->machineAliases + 1, - caps->machineAliases, - sizeof(caps->machineAliases[0]) * defIdx); - caps->machineTypes[0] = name; - caps->machineAliases[0] = alias; + char *name = qemuCaps->machineTypes[defIdx]; + char *alias = qemuCaps->machineAliases[defIdx]; + + memmove(qemuCaps->machineTypes + 1, + qemuCaps->machineTypes, + sizeof(qemuCaps->machineTypes[0]) * defIdx); + memmove(qemuCaps->machineAliases + 1, + qemuCaps->machineAliases, + sizeof(qemuCaps->machineAliases[0]) * defIdx); + qemuCaps->machineTypes[0] = name; + qemuCaps->machineAliases[0] = alias; } /* Format is: @@ -350,7 +350,7 @@ virQEMUCapsSetDefaultMachine(virQEMUCapsPtr caps, */ static int virQEMUCapsParseMachineTypesStr(const char *output, - virQEMUCapsPtr caps) + virQEMUCapsPtr qemuCaps) { const char *p = output; const char *next; @@ -375,7 +375,7 @@ virQEMUCapsParseMachineTypesStr(const char *output, p = t; if ((t = strstr(p, "(default)")) && (!next || t < next)) - defIdx = caps->nmachineTypes; + defIdx = qemuCaps->nmachineTypes; if ((t = strstr(p, "(alias of ")) && (!next || t < next)) { p = t + strlen("(alias of "); @@ -388,25 +388,25 @@ virQEMUCapsParseMachineTypesStr(const char *output, } } - if (VIR_REALLOC_N(caps->machineTypes, caps->nmachineTypes + 1) < 0 || - VIR_REALLOC_N(caps->machineAliases, caps->nmachineTypes + 1) < 0) { + if (VIR_REALLOC_N(qemuCaps->machineTypes, qemuCaps->nmachineTypes + 1) < 0 || + VIR_REALLOC_N(qemuCaps->machineAliases, qemuCaps->nmachineTypes + 1) < 0) { VIR_FREE(name); VIR_FREE(canonical); goto no_memory; } - caps->nmachineTypes++; + qemuCaps->nmachineTypes++; if (canonical) { - caps->machineTypes[caps->nmachineTypes-1] = canonical; - caps->machineAliases[caps->nmachineTypes-1] = name; + qemuCaps->machineTypes[qemuCaps->nmachineTypes-1] = canonical; + qemuCaps->machineAliases[qemuCaps->nmachineTypes-1] = name; } else { - caps->machineTypes[caps->nmachineTypes-1] = name; - caps->machineAliases[caps->nmachineTypes-1] = NULL; + qemuCaps->machineTypes[qemuCaps->nmachineTypes-1] = name; + qemuCaps->machineAliases[qemuCaps->nmachineTypes-1] = NULL; } } while ((p = next)); if (defIdx) - virQEMUCapsSetDefaultMachine(caps, defIdx); + virQEMUCapsSetDefaultMachine(qemuCaps, defIdx); return 0; @@ -416,7 +416,7 @@ no_memory: } static int -virQEMUCapsProbeMachineTypes(virQEMUCapsPtr caps, virQEMUCapsHookDataPtr hookData) +virQEMUCapsProbeMachineTypes(virQEMUCapsPtr qemuCaps, virQEMUCapsHookDataPtr hookData) { char *output; int ret = -1; @@ -427,13 +427,13 @@ virQEMUCapsProbeMachineTypes(virQEMUCapsPtr caps, virQEMUCapsHookDataPtr hookDat * Technically we could catch the exec() failure, but that's * in a sub-process so it's hard to feed back a useful error. */ - if (!virFileIsExecutable(caps->binary)) { + if (!virFileIsExecutable(qemuCaps->binary)) { virReportSystemError(errno, _("Cannot find QEMU binary %s"), - caps->binary); + qemuCaps->binary); return -1; } - cmd = virQEMUCapsProbeCommand(caps->binary, caps, hookData); + cmd = virQEMUCapsProbeCommand(qemuCaps->binary, qemuCaps, hookData); virCommandAddArgList(cmd, "-M", "?", NULL); virCommandSetOutputBuffer(cmd, &output); @@ -441,7 +441,7 @@ virQEMUCapsProbeMachineTypes(virQEMUCapsPtr caps, virQEMUCapsHookDataPtr hookDat if (virCommandRun(cmd, &status) < 0) goto cleanup; - if (virQEMUCapsParseMachineTypesStr(output, caps) < 0) + if (virQEMUCapsParseMachineTypesStr(output, qemuCaps) < 0) goto cleanup; ret = 0; @@ -456,7 +456,7 @@ cleanup: typedef int (*virQEMUCapsParseCPUModels)(const char *output, - virQEMUCapsPtr caps); + virQEMUCapsPtr qemuCaps); /* Format: * <arch> <model> @@ -465,7 +465,7 @@ typedef int */ static int virQEMUCapsParseX86Models(const char *output, - virQEMUCapsPtr caps) + virQEMUCapsPtr qemuCaps) { const char *p = output; const char *next; @@ -491,7 +491,7 @@ virQEMUCapsParseX86Models(const char *output, if (*p == '\0' || *p == '\n') continue; - if (VIR_EXPAND_N(caps->cpuDefinitions, caps->ncpuDefinitions, 1) < 0) { + if (VIR_EXPAND_N(qemuCaps->cpuDefinitions, qemuCaps->ncpuDefinitions, 1) < 0) { virReportOOMError(); goto cleanup; } @@ -506,7 +506,7 @@ virQEMUCapsParseX86Models(const char *output, len -= 2; } - if (!(caps->cpuDefinitions[caps->ncpuDefinitions - 1] = strndup(p, len))) { + if (!(qemuCaps->cpuDefinitions[qemuCaps->ncpuDefinitions - 1] = strndup(p, len))) { virReportOOMError(); goto cleanup; } @@ -523,7 +523,7 @@ cleanup: */ static int virQEMUCapsParsePPCModels(const char *output, - virQEMUCapsPtr caps) + virQEMUCapsPtr qemuCaps) { const char *p = output; const char *next; @@ -552,14 +552,14 @@ virQEMUCapsParsePPCModels(const char *output, if (*p == '\n') continue; - if (VIR_EXPAND_N(caps->cpuDefinitions, caps->ncpuDefinitions, 1) < 0) { + if (VIR_EXPAND_N(qemuCaps->cpuDefinitions, qemuCaps->ncpuDefinitions, 1) < 0) { virReportOOMError(); goto cleanup; } len = t - p - 1; - if (!(caps->cpuDefinitions[caps->ncpuDefinitions - 1] = strndup(p, len))) { + if (!(qemuCaps->cpuDefinitions[qemuCaps->ncpuDefinitions - 1] = strndup(p, len))) { virReportOOMError(); goto cleanup; } @@ -572,32 +572,32 @@ cleanup: } static int -virQEMUCapsProbeCPUModels(virQEMUCapsPtr caps, virQEMUCapsHookDataPtr hookData) +virQEMUCapsProbeCPUModels(virQEMUCapsPtr qemuCaps, virQEMUCapsHookDataPtr hookData) { char *output = NULL; int ret = -1; virQEMUCapsParseCPUModels parse; virCommandPtr cmd; - if (caps->arch == VIR_ARCH_I686 || - caps->arch == VIR_ARCH_X86_64) + if (qemuCaps->arch == VIR_ARCH_I686 || + qemuCaps->arch == VIR_ARCH_X86_64) parse = virQEMUCapsParseX86Models; - else if (caps->arch == VIR_ARCH_PPC64) + else if (qemuCaps->arch == VIR_ARCH_PPC64) parse = virQEMUCapsParsePPCModels; else { VIR_DEBUG("don't know how to parse %s CPU models", - virArchToString(caps->arch)); + virArchToString(qemuCaps->arch)); return 0; } - cmd = virQEMUCapsProbeCommand(caps->binary, caps, hookData); + cmd = virQEMUCapsProbeCommand(qemuCaps->binary, qemuCaps, hookData); virCommandAddArgList(cmd, "-cpu", "?", NULL); virCommandSetOutputBuffer(cmd, &output); if (virCommandRun(cmd, NULL) < 0) goto cleanup; - if (parse(output, caps) < 0) + if (parse(output, qemuCaps) < 0) goto cleanup; ret = 0; @@ -920,8 +920,8 @@ virCapsPtr virQEMUCapsInit(virQEMUCapsCachePtr cache) */ for (i = 0 ; i < VIR_ARCH_LAST ; i++) if (virQEMUCapsInitGuest(caps, cache, - virArchFromHost(), - i) < 0) + virArchFromHost(), + i) < 0) goto error; /* QEMU Requires an emulator in the XML */ @@ -942,130 +942,130 @@ virQEMUCapsComputeCmdFlags(const char *help, unsigned int version, unsigned int is_kvm, unsigned int kvm_version, - virQEMUCapsPtr caps, + virQEMUCapsPtr qemuCaps, bool check_yajl ATTRIBUTE_UNUSED) { const char *p; const char *fsdev, *netdev; if (strstr(help, "-no-kqemu")) - virQEMUCapsSet(caps, QEMU_CAPS_KQEMU); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_KQEMU); if (strstr(help, "-enable-kqemu")) - virQEMUCapsSet(caps, QEMU_CAPS_ENABLE_KQEMU); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KQEMU); if (strstr(help, "-no-kvm")) - virQEMUCapsSet(caps, QEMU_CAPS_KVM); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_KVM); if (strstr(help, "-enable-kvm")) - virQEMUCapsSet(caps, QEMU_CAPS_ENABLE_KVM); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KVM); if (strstr(help, "-no-reboot")) - virQEMUCapsSet(caps, QEMU_CAPS_NO_REBOOT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_REBOOT); if (strstr(help, "-name")) { - virQEMUCapsSet(caps, QEMU_CAPS_NAME); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME); if (strstr(help, ",process=")) - virQEMUCapsSet(caps, QEMU_CAPS_NAME_PROCESS); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME_PROCESS); } if (strstr(help, "-uuid")) - virQEMUCapsSet(caps, QEMU_CAPS_UUID); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_UUID); if (strstr(help, "-xen-domid")) - virQEMUCapsSet(caps, QEMU_CAPS_XEN_DOMID); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_XEN_DOMID); else if (strstr(help, "-domid")) - virQEMUCapsSet(caps, QEMU_CAPS_DOMID); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DOMID); if (strstr(help, "-drive")) { const char *cache = strstr(help, "cache="); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE); if (cache && (p = strchr(cache, ']'))) { if (memmem(cache, p - cache, "on|off", sizeof("on|off") - 1) == NULL) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_V2); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2); if (memmem(cache, p - cache, "directsync", sizeof("directsync") - 1)) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC); if (memmem(cache, p - cache, "unsafe", sizeof("unsafe") - 1)) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_UNSAFE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE); } if (strstr(help, "format=")) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_FORMAT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT); if (strstr(help, "readonly=")) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_READONLY); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_READONLY); if (strstr(help, "aio=threads|native")) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_AIO); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_AIO); if (strstr(help, "copy-on-read=on|off")) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_COPY_ON_READ); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ); if (strstr(help, "bps=")) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_IOTUNE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE); } if ((p = strstr(help, "-vga")) && !strstr(help, "-std-vga")) { const char *nl = strstr(p, "\n"); - virQEMUCapsSet(caps, QEMU_CAPS_VGA); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA); if (strstr(p, "|qxl")) - virQEMUCapsSet(caps, QEMU_CAPS_VGA_QXL); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_QXL); if ((p = strstr(p, "|none")) && p < nl) - virQEMUCapsSet(caps, QEMU_CAPS_VGA_NONE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_NONE); } if (strstr(help, "-spice")) - virQEMUCapsSet(caps, QEMU_CAPS_SPICE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SPICE); if (strstr(help, "-vnc")) - virQEMUCapsSet(caps, QEMU_CAPS_VNC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC); if (strstr(help, "seamless-migration=")) - virQEMUCapsSet(caps, QEMU_CAPS_SEAMLESS_MIGRATION); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SEAMLESS_MIGRATION); if (strstr(help, "boot=on")) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_BOOT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_BOOT); if (strstr(help, "serial=s")) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_SERIAL); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL); if (strstr(help, "-pcidevice")) - virQEMUCapsSet(caps, QEMU_CAPS_PCIDEVICE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCIDEVICE); if (strstr(help, "-mem-path")) - virQEMUCapsSet(caps, QEMU_CAPS_MEM_PATH); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MEM_PATH); if (strstr(help, "-chardev")) { - virQEMUCapsSet(caps, QEMU_CAPS_CHARDEV); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV); if (strstr(help, "-chardev spicevmc")) - virQEMUCapsSet(caps, QEMU_CAPS_CHARDEV_SPICEVMC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC); } if (strstr(help, "-balloon")) - virQEMUCapsSet(caps, QEMU_CAPS_BALLOON); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_BALLOON); if (strstr(help, "-device")) { - virQEMUCapsSet(caps, QEMU_CAPS_DEVICE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE); /* * When -device was introduced, qemu already supported drive's * readonly option but didn't advertise that. */ - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_READONLY); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_READONLY); } if (strstr(help, "-nodefconfig")) - virQEMUCapsSet(caps, QEMU_CAPS_NODEFCONFIG); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NODEFCONFIG); if (strstr(help, "-no-user-config")) - virQEMUCapsSet(caps, QEMU_CAPS_NO_USER_CONFIG); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG); /* The trailing ' ' is important to avoid a bogus match */ if (strstr(help, "-rtc ")) - virQEMUCapsSet(caps, QEMU_CAPS_RTC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC); /* to wit */ if (strstr(help, "-rtc-td-hack")) - virQEMUCapsSet(caps, QEMU_CAPS_RTC_TD_HACK); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC_TD_HACK); if (strstr(help, "-no-hpet")) - virQEMUCapsSet(caps, QEMU_CAPS_NO_HPET); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET); if (strstr(help, "-no-acpi")) - virQEMUCapsSet(caps, QEMU_CAPS_NO_ACPI); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI); if (strstr(help, "-no-kvm-pit-reinjection")) - virQEMUCapsSet(caps, QEMU_CAPS_NO_KVM_PIT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_KVM_PIT); if (strstr(help, "-tdf")) - virQEMUCapsSet(caps, QEMU_CAPS_TDF); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_TDF); if (strstr(help, "-enable-nesting")) - virQEMUCapsSet(caps, QEMU_CAPS_NESTING); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NESTING); if (strstr(help, ",menu=on")) - virQEMUCapsSet(caps, QEMU_CAPS_BOOT_MENU); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_BOOT_MENU); if (strstr(help, ",reboot-timeout=rb_time")) - virQEMUCapsSet(caps, QEMU_CAPS_REBOOT_TIMEOUT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_REBOOT_TIMEOUT); if ((fsdev = strstr(help, "-fsdev"))) { - virQEMUCapsSet(caps, QEMU_CAPS_FSDEV); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV); if (strstr(fsdev, "readonly")) - virQEMUCapsSet(caps, QEMU_CAPS_FSDEV_READONLY); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_READONLY); if (strstr(fsdev, "writeout")) - virQEMUCapsSet(caps, QEMU_CAPS_FSDEV_WRITEOUT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT); } if (strstr(help, "-smbios type")) - virQEMUCapsSet(caps, QEMU_CAPS_SMBIOS_TYPE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE); if (strstr(help, "-sandbox")) - virQEMUCapsSet(caps, QEMU_CAPS_SECCOMP_SANDBOX); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX); if ((netdev = strstr(help, "-netdev"))) { /* Disable -netdev on 0.12 since although it exists, @@ -1074,26 +1074,26 @@ virQEMUCapsComputeCmdFlags(const char *help, * But see below about RHEL build. */ if (version >= 13000) { if (strstr(netdev, "bridge")) - virQEMUCapsSet(caps, QEMU_CAPS_NETDEV_BRIDGE); - virQEMUCapsSet(caps, QEMU_CAPS_NETDEV); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV); } } if (strstr(help, "-sdl")) - virQEMUCapsSet(caps, QEMU_CAPS_SDL); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL); if (strstr(help, "cores=") && strstr(help, "threads=") && strstr(help, "sockets=")) - virQEMUCapsSet(caps, QEMU_CAPS_SMP_TOPOLOGY); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY); if (version >= 9000) - virQEMUCapsSet(caps, QEMU_CAPS_VNC_COLON); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_COLON); if (is_kvm && (version >= 10000 || kvm_version >= 74)) - virQEMUCapsSet(caps, QEMU_CAPS_VNET_HDR); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNET_HDR); if (strstr(help, ",vhost=")) { - virQEMUCapsSet(caps, QEMU_CAPS_VHOST_NET); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOST_NET); } /* Do not use -no-shutdown if qemu doesn't support it or SIGTERM handling @@ -1101,10 +1101,10 @@ virQEMUCapsComputeCmdFlags(const char *help, * 0.14.* and 0.15.0) */ if (strstr(help, "-no-shutdown") && (version < 14000 || version > 15000)) - virQEMUCapsSet(caps, QEMU_CAPS_NO_SHUTDOWN); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN); if (strstr(help, "dump-guest-core=on|off")) - virQEMUCapsSet(caps, QEMU_CAPS_DUMP_GUEST_CORE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_CORE); /* * Handling of -incoming arg with varying features @@ -1119,25 +1119,25 @@ virQEMUCapsComputeCmdFlags(const char *help, * while waiting for data, so pretend it doesn't exist */ if (version >= 10000) { - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP); - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC); if (version >= 12000) { - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_UNIX); - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_FD); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD); } } else if (kvm_version >= 79) { - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP); if (kvm_version >= 80) - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC); } else if (kvm_version > 0) { - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_KVM_STDIO); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_KVM_STDIO); } if (version >= 10000) - virQEMUCapsSet(caps, QEMU_CAPS_0_10); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_0_10); if (version >= 11000) - virQEMUCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_SG_IO); + virQEMUCapsSet(qemuCaps, 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 @@ -1150,11 +1150,11 @@ virQEMUCapsComputeCmdFlags(const char *help, */ #if WITH_YAJL if (version >= 13000) { - virQEMUCapsSet(caps, QEMU_CAPS_MONITOR_JSON); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON); } else if (version >= 12000 && strstr(help, "libvirt")) { - virQEMUCapsSet(caps, QEMU_CAPS_MONITOR_JSON); - virQEMUCapsSet(caps, QEMU_CAPS_NETDEV); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV); } #else /* Starting with qemu 0.15 and newer, upstream qemu no longer @@ -1173,12 +1173,12 @@ virQEMUCapsComputeCmdFlags(const char *help, "compiled with yajl")); return -1; } - virQEMUCapsSet(caps, QEMU_CAPS_NETDEV); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV); } #endif if (version >= 13000) - virQEMUCapsSet(caps, QEMU_CAPS_PCI_MULTIFUNCTION); + virQEMUCapsSet(qemuCaps, 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,?", @@ -1191,13 +1191,13 @@ virQEMUCapsComputeCmdFlags(const char *help, * log and refuse to start, so it would be immediately obvious). */ if (version >= 12000) - virQEMUCapsSet(caps, QEMU_CAPS_PCI_ROMBAR); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_ROMBAR); if (version >= 11000) - virQEMUCapsSet(caps, QEMU_CAPS_CPU_HOST); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_HOST); if (version >= 1002000) - virQEMUCapsSet(caps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY); return 0; } @@ -1227,7 +1227,7 @@ virQEMUCapsComputeCmdFlags(const char *help, int virQEMUCapsParseHelpStr(const char *qemu, const char *help, - virQEMUCapsPtr caps, + virQEMUCapsPtr qemuCaps, unsigned int *version, unsigned int *is_kvm, unsigned int *kvm_version, @@ -1288,10 +1288,10 @@ int virQEMUCapsParseHelpStr(const char *qemu, *version = (major * 1000 * 1000) + (minor * 1000) + micro; if (virQEMUCapsComputeCmdFlags(help, *version, *is_kvm, *kvm_version, - caps, check_yajl) < 0) + qemuCaps, check_yajl) < 0) goto cleanup; - strflags = virBitmapString(caps->flags); + strflags = virBitmapString(qemuCaps->flags); VIR_DEBUG("Version %u.%u.%u, cooked version %u, flags %s", major, minor, micro, *version, NULLSTR(strflags)); VIR_FREE(strflags); @@ -1433,7 +1433,7 @@ static struct virQEMUCapsObjectTypeProps virQEMUCapsObjectProps[] = { static void -virQEMUCapsProcessStringFlags(virQEMUCapsPtr caps, +virQEMUCapsProcessStringFlags(virQEMUCapsPtr qemuCaps, size_t nflags, struct virQEMUCapsStringFlags *flags, size_t nvalues, @@ -1443,7 +1443,7 @@ virQEMUCapsProcessStringFlags(virQEMUCapsPtr caps, for (i = 0 ; i < nflags ; i++) { for (j = 0 ; j < nvalues ; j++) { if (STREQ(values[j], flags[i].value)) { - virQEMUCapsSet(caps, flags[i].flag); + virQEMUCapsSet(qemuCaps, flags[i].flag); break; } } @@ -1563,7 +1563,7 @@ cleanup: int -virQEMUCapsParseDeviceStr(virQEMUCapsPtr caps, const char *str) +virQEMUCapsParseDeviceStr(virQEMUCapsPtr qemuCaps, const char *str) { int nvalues; char **values; @@ -1571,28 +1571,28 @@ virQEMUCapsParseDeviceStr(virQEMUCapsPtr caps, const char *str) if ((nvalues = virQEMUCapsParseDeviceStrObjectTypes(str, &values)) < 0) return -1; - virQEMUCapsProcessStringFlags(caps, - ARRAY_CARDINALITY(virQEMUCapsObjectTypes), - virQEMUCapsObjectTypes, - nvalues, values); + virQEMUCapsProcessStringFlags(qemuCaps, + ARRAY_CARDINALITY(virQEMUCapsObjectTypes), + virQEMUCapsObjectTypes, + nvalues, values); virQEMUCapsFreeStringList(nvalues, values); for (i = 0 ; i < ARRAY_CARDINALITY(virQEMUCapsObjectProps); i++) { const char *type = virQEMUCapsObjectProps[i].type; if ((nvalues = virQEMUCapsParseDeviceStrObjectProps(str, - type, - &values)) < 0) + type, + &values)) < 0) return -1; - virQEMUCapsProcessStringFlags(caps, - virQEMUCapsObjectProps[i].nprops, - virQEMUCapsObjectProps[i].props, - nvalues, values); + virQEMUCapsProcessStringFlags(qemuCaps, + virQEMUCapsObjectProps[i].nprops, + virQEMUCapsObjectProps[i].props, + nvalues, values); virQEMUCapsFreeStringList(nvalues, values); } /* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */ - if (virQEMUCapsGet(caps, QEMU_CAPS_CHARDEV_SPICEVMC)) - virQEMUCapsClear(caps, QEMU_CAPS_DEVICE_SPICEVMC); + if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC)) + virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC); return 0; } @@ -1600,7 +1600,7 @@ virQEMUCapsParseDeviceStr(virQEMUCapsPtr caps, const char *str) static int virQEMUCapsExtractDeviceStr(const char *qemu, - virQEMUCapsPtr caps, + virQEMUCapsPtr qemuCaps, virQEMUCapsHookDataPtr hookData) { char *output = NULL; @@ -1615,7 +1615,7 @@ virQEMUCapsExtractDeviceStr(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 = virQEMUCapsProbeCommand(qemu, caps, hookData); + cmd = virQEMUCapsProbeCommand(qemu, qemuCaps, hookData); virCommandAddArgList(cmd, "-device", "?", "-device", "pci-assign,?", @@ -1633,7 +1633,7 @@ virQEMUCapsExtractDeviceStr(const char *qemu, if (virCommandRun(cmd, NULL) < 0) goto cleanup; - ret = virQEMUCapsParseDeviceStr(caps, output); + ret = virQEMUCapsParseDeviceStr(qemuCaps, output); cleanup: VIR_FREE(output); @@ -1676,27 +1676,27 @@ int virQEMUCapsGetDefaultVersion(virCapsPtr caps, virQEMUCapsPtr virQEMUCapsNew(void) { - virQEMUCapsPtr caps; + virQEMUCapsPtr qemuCaps; if (virQEMUCapsInitialize() < 0) return NULL; - if (!(caps = virObjectNew(virQEMUCapsClass))) + if (!(qemuCaps = virObjectNew(virQEMUCapsClass))) return NULL; - if (!(caps->flags = virBitmapNew(QEMU_CAPS_LAST))) + if (!(qemuCaps->flags = virBitmapNew(QEMU_CAPS_LAST))) goto no_memory; - return caps; + return qemuCaps; no_memory: virReportOOMError(); - virObjectUnref(caps); + virObjectUnref(qemuCaps); return NULL; } -virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr caps) +virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps) { virQEMUCapsPtr ret = virQEMUCapsNew(); size_t i; @@ -1704,31 +1704,31 @@ virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr caps) if (!ret) return NULL; - virBitmapCopy(ret->flags, caps->flags); + virBitmapCopy(ret->flags, qemuCaps->flags); - ret->usedQMP = caps->usedQMP; - ret->version = caps->version; - ret->kvmVersion = caps->kvmVersion; - ret->arch = caps->arch; + ret->usedQMP = qemuCaps->usedQMP; + ret->version = qemuCaps->version; + ret->kvmVersion = qemuCaps->kvmVersion; + ret->arch = qemuCaps->arch; - if (VIR_ALLOC_N(ret->cpuDefinitions, caps->ncpuDefinitions) < 0) + if (VIR_ALLOC_N(ret->cpuDefinitions, qemuCaps->ncpuDefinitions) < 0) goto no_memory; - ret->ncpuDefinitions = caps->ncpuDefinitions; - for (i = 0 ; i < caps->ncpuDefinitions ; i++) { - if (!(ret->cpuDefinitions[i] = strdup(caps->cpuDefinitions[i]))) + ret->ncpuDefinitions = qemuCaps->ncpuDefinitions; + for (i = 0 ; i < qemuCaps->ncpuDefinitions ; i++) { + if (!(ret->cpuDefinitions[i] = strdup(qemuCaps->cpuDefinitions[i]))) goto no_memory; } - if (VIR_ALLOC_N(ret->machineTypes, caps->nmachineTypes) < 0) + if (VIR_ALLOC_N(ret->machineTypes, qemuCaps->nmachineTypes) < 0) goto no_memory; - if (VIR_ALLOC_N(ret->machineAliases, caps->nmachineTypes) < 0) + if (VIR_ALLOC_N(ret->machineAliases, qemuCaps->nmachineTypes) < 0) goto no_memory; - ret->nmachineTypes = caps->nmachineTypes; - for (i = 0 ; i < caps->nmachineTypes ; i++) { - if (!(ret->machineTypes[i] = strdup(caps->machineTypes[i]))) + ret->nmachineTypes = qemuCaps->nmachineTypes; + for (i = 0 ; i < qemuCaps->nmachineTypes ; i++) { + if (!(ret->machineTypes[i] = strdup(qemuCaps->machineTypes[i]))) goto no_memory; - if (caps->machineAliases[i] && - !(ret->machineAliases[i] = strdup(caps->machineAliases[i]))) + if (qemuCaps->machineAliases[i] && + !(ret->machineAliases[i] = strdup(qemuCaps->machineAliases[i]))) goto no_memory; } @@ -1743,98 +1743,98 @@ no_memory: void virQEMUCapsDispose(void *obj) { - virQEMUCapsPtr caps = obj; + virQEMUCapsPtr qemuCaps = obj; size_t i; - for (i = 0 ; i < caps->nmachineTypes ; i++) { - VIR_FREE(caps->machineTypes[i]); - VIR_FREE(caps->machineAliases[i]); + for (i = 0 ; i < qemuCaps->nmachineTypes ; i++) { + VIR_FREE(qemuCaps->machineTypes[i]); + VIR_FREE(qemuCaps->machineAliases[i]); } - VIR_FREE(caps->machineTypes); - VIR_FREE(caps->machineAliases); + VIR_FREE(qemuCaps->machineTypes); + VIR_FREE(qemuCaps->machineAliases); - for (i = 0 ; i < caps->ncpuDefinitions ; i++) { - VIR_FREE(caps->cpuDefinitions[i]); + for (i = 0 ; i < qemuCaps->ncpuDefinitions ; i++) { + VIR_FREE(qemuCaps->cpuDefinitions[i]); } - VIR_FREE(caps->cpuDefinitions); + VIR_FREE(qemuCaps->cpuDefinitions); - virBitmapFree(caps->flags); + virBitmapFree(qemuCaps->flags); - VIR_FREE(caps->binary); + VIR_FREE(qemuCaps->binary); } void -virQEMUCapsSet(virQEMUCapsPtr caps, +virQEMUCapsSet(virQEMUCapsPtr qemuCaps, enum virQEMUCapsFlags flag) { - ignore_value(virBitmapSetBit(caps->flags, flag)); + ignore_value(virBitmapSetBit(qemuCaps->flags, flag)); } void -virQEMUCapsSetList(virQEMUCapsPtr caps, ...) +virQEMUCapsSetList(virQEMUCapsPtr qemuCaps, ...) { va_list list; int flag; - va_start(list, caps); + va_start(list, qemuCaps); while ((flag = va_arg(list, int)) < QEMU_CAPS_LAST) - ignore_value(virBitmapSetBit(caps->flags, flag)); + ignore_value(virBitmapSetBit(qemuCaps->flags, flag)); va_end(list); } void -virQEMUCapsClear(virQEMUCapsPtr caps, +virQEMUCapsClear(virQEMUCapsPtr qemuCaps, enum virQEMUCapsFlags flag) { - ignore_value(virBitmapClearBit(caps->flags, flag)); + ignore_value(virBitmapClearBit(qemuCaps->flags, flag)); } -char *virQEMUCapsFlagsString(virQEMUCapsPtr caps) +char *virQEMUCapsFlagsString(virQEMUCapsPtr qemuCaps) { - return virBitmapString(caps->flags); + return virBitmapString(qemuCaps->flags); } bool -virQEMUCapsGet(virQEMUCapsPtr caps, +virQEMUCapsGet(virQEMUCapsPtr qemuCaps, enum virQEMUCapsFlags flag) { bool b; - if (!caps || virBitmapGetBit(caps->flags, flag, &b) < 0) + if (!qemuCaps || virBitmapGetBit(qemuCaps->flags, flag, &b) < 0) return false; else return b; } -const char *virQEMUCapsGetBinary(virQEMUCapsPtr caps) +const char *virQEMUCapsGetBinary(virQEMUCapsPtr qemuCaps) { - return caps->binary; + return qemuCaps->binary; } -virArch virQEMUCapsGetArch(virQEMUCapsPtr caps) +virArch virQEMUCapsGetArch(virQEMUCapsPtr qemuCaps) { - return caps->arch; + return qemuCaps->arch; } -unsigned int virQEMUCapsGetVersion(virQEMUCapsPtr caps) +unsigned int virQEMUCapsGetVersion(virQEMUCapsPtr qemuCaps) { - return caps->version; + return qemuCaps->version; } -unsigned int virQEMUCapsGetKVMVersion(virQEMUCapsPtr caps) +unsigned int virQEMUCapsGetKVMVersion(virQEMUCapsPtr qemuCaps) { - return caps->kvmVersion; + return qemuCaps->kvmVersion; } -int virQEMUCapsAddCPUDefinition(virQEMUCapsPtr caps, +int virQEMUCapsAddCPUDefinition(virQEMUCapsPtr qemuCaps, const char *name) { char *tmp = strdup(name); @@ -1842,34 +1842,34 @@ int virQEMUCapsAddCPUDefinition(virQEMUCapsPtr caps, virReportOOMError(); return -1; } - if (VIR_EXPAND_N(caps->cpuDefinitions, caps->ncpuDefinitions, 1) < 0) { + if (VIR_EXPAND_N(qemuCaps->cpuDefinitions, qemuCaps->ncpuDefinitions, 1) < 0) { VIR_FREE(tmp); virReportOOMError(); return -1; } - caps->cpuDefinitions[caps->ncpuDefinitions-1] = tmp; + qemuCaps->cpuDefinitions[qemuCaps->ncpuDefinitions-1] = tmp; return 0; } -size_t virQEMUCapsGetCPUDefinitions(virQEMUCapsPtr caps, +size_t virQEMUCapsGetCPUDefinitions(virQEMUCapsPtr qemuCaps, char ***names) { if (names) - *names = caps->cpuDefinitions; - return caps->ncpuDefinitions; + *names = qemuCaps->cpuDefinitions; + return qemuCaps->ncpuDefinitions; } -size_t virQEMUCapsGetMachineTypes(virQEMUCapsPtr caps, +size_t virQEMUCapsGetMachineTypes(virQEMUCapsPtr qemuCaps, char ***names) { if (names) - *names = caps->machineTypes; - return caps->nmachineTypes; + *names = qemuCaps->machineTypes; + return qemuCaps->nmachineTypes; } -int virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr caps, +int virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr qemuCaps, size_t *nmachines, virCapsGuestMachinePtr **machines) { @@ -1877,21 +1877,21 @@ int virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr caps, *nmachines = 0; *machines = NULL; - if (VIR_ALLOC_N(*machines, caps->nmachineTypes) < 0) + if (VIR_ALLOC_N(*machines, qemuCaps->nmachineTypes) < 0) goto no_memory; - *nmachines = caps->nmachineTypes; + *nmachines = qemuCaps->nmachineTypes; - for (i = 0 ; i < caps->nmachineTypes ; i++) { + for (i = 0 ; i < qemuCaps->nmachineTypes ; i++) { virCapsGuestMachinePtr mach; if (VIR_ALLOC(mach) < 0) goto no_memory; - if (caps->machineAliases[i]) { - if (!(mach->name = strdup(caps->machineAliases[i]))) + if (qemuCaps->machineAliases[i]) { + if (!(mach->name = strdup(qemuCaps->machineAliases[i]))) goto no_memory; - if (!(mach->canonical = strdup(caps->machineTypes[i]))) + if (!(mach->canonical = strdup(qemuCaps->machineTypes[i]))) goto no_memory; } else { - if (!(mach->name = strdup(caps->machineTypes[i]))) + if (!(mach->name = strdup(qemuCaps->machineTypes[i]))) goto no_memory; } (*machines)[i] = mach; @@ -1909,7 +1909,7 @@ no_memory: -const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr caps, +const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr qemuCaps, const char *name) { size_t i; @@ -1917,11 +1917,11 @@ const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr caps, if (!name) return NULL; - for (i = 0 ; i < caps->nmachineTypes ; i++) { - if (!caps->machineAliases[i]) + for (i = 0 ; i < qemuCaps->nmachineTypes ; i++) { + if (!qemuCaps->machineAliases[i]) continue; - if (STREQ(caps->machineAliases[i], name)) - return caps->machineTypes[i]; + if (STREQ(qemuCaps->machineAliases[i], name)) + return qemuCaps->machineTypes[i]; } return name; @@ -1929,7 +1929,7 @@ const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr caps, static int -virQEMUCapsProbeQMPCommands(virQEMUCapsPtr caps, +virQEMUCapsProbeQMPCommands(virQEMUCapsPtr qemuCaps, qemuMonitorPtr mon) { char **commands = NULL; @@ -1942,29 +1942,29 @@ virQEMUCapsProbeQMPCommands(virQEMUCapsPtr caps, for (i = 0 ; i < ncommands ; i++) { char *name = commands[i]; if (STREQ(name, "system_wakeup")) - virQEMUCapsSet(caps, QEMU_CAPS_WAKEUP); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_WAKEUP); else if (STREQ(name, "transaction")) - virQEMUCapsSet(caps, QEMU_CAPS_TRANSACTION); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_TRANSACTION); else if (STREQ(name, "block_job_cancel")) - virQEMUCapsSet(caps, QEMU_CAPS_BLOCKJOB_SYNC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC); else if (STREQ(name, "block-job-cancel")) - virQEMUCapsSet(caps, QEMU_CAPS_BLOCKJOB_ASYNC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC); else if (STREQ(name, "dump-guest-memory")) - virQEMUCapsSet(caps, QEMU_CAPS_DUMP_GUEST_MEMORY); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_MEMORY); else if (STREQ(name, "query-spice")) - virQEMUCapsSet(caps, QEMU_CAPS_SPICE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SPICE); else if (STREQ(name, "query-kvm")) - virQEMUCapsSet(caps, QEMU_CAPS_KVM); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_KVM); else if (STREQ(name, "block-commit")) - virQEMUCapsSet(caps, QEMU_CAPS_BLOCK_COMMIT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_BLOCK_COMMIT); else if (STREQ(name, "query-vnc")) - virQEMUCapsSet(caps, QEMU_CAPS_VNC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC); else if (STREQ(name, "drive-mirror")) - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_MIRROR); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_MIRROR); else if (STREQ(name, "blockdev-snapshot-sync")) - virQEMUCapsSet(caps, QEMU_CAPS_DISK_SNAPSHOT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DISK_SNAPSHOT); else if (STREQ(name, "add-fd")) - virQEMUCapsSet(caps, QEMU_CAPS_ADD_FD); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_ADD_FD); VIR_FREE(name); } VIR_FREE(commands); @@ -1973,7 +1973,7 @@ virQEMUCapsProbeQMPCommands(virQEMUCapsPtr caps, * management control of set numbering, and did not have a * counterpart -add-fd command line option. We require the * add-fd features from 1.3 or later. */ - if (virQEMUCapsGet(caps, QEMU_CAPS_ADD_FD)) { + if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ADD_FD)) { int fd = open("/dev/null", O_RDONLY); if (fd < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", @@ -1981,7 +1981,7 @@ virQEMUCapsProbeQMPCommands(virQEMUCapsPtr caps, return -1; } if (qemuMonitorAddFd(mon, 0, fd, "/dev/null") < 0) - virQEMUCapsClear(caps, QEMU_CAPS_ADD_FD); + virQEMUCapsClear(qemuCaps, QEMU_CAPS_ADD_FD); VIR_FORCE_CLOSE(fd); } @@ -1990,7 +1990,7 @@ virQEMUCapsProbeQMPCommands(virQEMUCapsPtr caps, static int -virQEMUCapsProbeQMPEvents(virQEMUCapsPtr caps, +virQEMUCapsProbeQMPEvents(virQEMUCapsPtr qemuCaps, qemuMonitorPtr mon) { char **events = NULL; @@ -2004,9 +2004,9 @@ virQEMUCapsProbeQMPEvents(virQEMUCapsPtr caps, char *name = events[i]; if (STREQ(name, "BALLOON_CHANGE")) - virQEMUCapsSet(caps, QEMU_CAPS_BALLOON_EVENT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_BALLOON_EVENT); if (STREQ(name, "SPICE_MIGRATE_COMPLETED")) - virQEMUCapsSet(caps, QEMU_CAPS_SEAMLESS_MIGRATION); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SEAMLESS_MIGRATION); VIR_FREE(name); } VIR_FREE(events); @@ -2016,7 +2016,7 @@ virQEMUCapsProbeQMPEvents(virQEMUCapsPtr caps, static int -virQEMUCapsProbeQMPObjects(virQEMUCapsPtr caps, +virQEMUCapsProbeQMPObjects(virQEMUCapsPtr qemuCaps, qemuMonitorPtr mon) { int nvalues; @@ -2025,10 +2025,10 @@ virQEMUCapsProbeQMPObjects(virQEMUCapsPtr caps, if ((nvalues = qemuMonitorGetObjectTypes(mon, &values)) < 0) return -1; - virQEMUCapsProcessStringFlags(caps, - ARRAY_CARDINALITY(virQEMUCapsObjectTypes), - virQEMUCapsObjectTypes, - nvalues, values); + virQEMUCapsProcessStringFlags(qemuCaps, + ARRAY_CARDINALITY(virQEMUCapsObjectTypes), + virQEMUCapsObjectTypes, + nvalues, values); virQEMUCapsFreeStringList(nvalues, values); for (i = 0 ; i < ARRAY_CARDINALITY(virQEMUCapsObjectProps); i++) { @@ -2037,26 +2037,26 @@ virQEMUCapsProbeQMPObjects(virQEMUCapsPtr caps, type, &values)) < 0) return -1; - virQEMUCapsProcessStringFlags(caps, - virQEMUCapsObjectProps[i].nprops, - virQEMUCapsObjectProps[i].props, - nvalues, values); + virQEMUCapsProcessStringFlags(qemuCaps, + virQEMUCapsObjectProps[i].nprops, + virQEMUCapsObjectProps[i].props, + nvalues, values); virQEMUCapsFreeStringList(nvalues, values); } /* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */ - if (virQEMUCapsGet(caps, QEMU_CAPS_CHARDEV_SPICEVMC)) - virQEMUCapsClear(caps, QEMU_CAPS_DEVICE_SPICEVMC); + if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC)) + virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC); /* If qemu supports newer -device qxl it supports -vga qxl as well */ - if (virQEMUCapsGet(caps, QEMU_CAPS_DEVICE_QXL)) - virQEMUCapsSet(caps, QEMU_CAPS_VGA_QXL); + if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL)) + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_QXL); return 0; } static int -virQEMUCapsProbeQMPMachineTypes(virQEMUCapsPtr caps, +virQEMUCapsProbeQMPMachineTypes(virQEMUCapsPtr qemuCaps, qemuMonitorPtr mon) { qemuMonitorMachineInfoPtr *machines = NULL; @@ -2068,33 +2068,33 @@ virQEMUCapsProbeQMPMachineTypes(virQEMUCapsPtr caps, if ((nmachines = qemuMonitorGetMachines(mon, &machines)) < 0) goto cleanup; - if (VIR_ALLOC_N(caps->machineTypes, nmachines) < 0) { + if (VIR_ALLOC_N(qemuCaps->machineTypes, nmachines) < 0) { virReportOOMError(); goto cleanup; } - if (VIR_ALLOC_N(caps->machineAliases, nmachines) < 0) { + if (VIR_ALLOC_N(qemuCaps->machineAliases, nmachines) < 0) { virReportOOMError(); goto cleanup; } for (i = 0 ; i < nmachines ; i++) { if (machines[i]->alias) { - if (!(caps->machineAliases[i] = strdup(machines[i]->alias))) { + if (!(qemuCaps->machineAliases[i] = strdup(machines[i]->alias))) { virReportOOMError(); goto cleanup; } } - if (!(caps->machineTypes[i] = strdup(machines[i]->name))) { + if (!(qemuCaps->machineTypes[i] = strdup(machines[i]->name))) { virReportOOMError(); goto cleanup; } if (machines[i]->isDefault) defIdx = i; } - caps->nmachineTypes = nmachines; + qemuCaps->nmachineTypes = nmachines; if (defIdx) - virQEMUCapsSetDefaultMachine(caps, defIdx); + virQEMUCapsSetDefaultMachine(qemuCaps, defIdx); ret = 0; @@ -2107,7 +2107,7 @@ cleanup: static int -virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr caps, +virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr qemuCaps, qemuMonitorPtr mon) { int ncpuDefinitions; @@ -2116,21 +2116,21 @@ virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr caps, if ((ncpuDefinitions = qemuMonitorGetCPUDefinitions(mon, &cpuDefinitions)) < 0) return -1; - caps->ncpuDefinitions = ncpuDefinitions; - caps->cpuDefinitions = cpuDefinitions; + qemuCaps->ncpuDefinitions = ncpuDefinitions; + qemuCaps->cpuDefinitions = cpuDefinitions; return 0; } static int -virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr caps, +virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr qemuCaps, qemuMonitorPtr mon) { bool enabled = false; bool present = false; - if (!virQEMUCapsGet(caps, QEMU_CAPS_KVM)) + if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) return 0; if (qemuMonitorGetKVMState(mon, &enabled, &present) < 0) @@ -2145,28 +2145,28 @@ virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr caps, * not enabled by default we need to change the flag. */ if (!present) { - virQEMUCapsClear(caps, QEMU_CAPS_KVM); + virQEMUCapsClear(qemuCaps, QEMU_CAPS_KVM); } else if (!enabled) { - virQEMUCapsClear(caps, QEMU_CAPS_KVM); - virQEMUCapsSet(caps, QEMU_CAPS_ENABLE_KVM); + virQEMUCapsClear(qemuCaps, QEMU_CAPS_KVM); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KVM); } return 0; } -int virQEMUCapsProbeQMP(virQEMUCapsPtr caps, +int virQEMUCapsProbeQMP(virQEMUCapsPtr qemuCaps, qemuMonitorPtr mon) { - VIR_DEBUG("caps=%p mon=%p", caps, mon); + VIR_DEBUG("qemuCaps=%p mon=%p", qemuCaps, mon); - if (caps->usedQMP) + if (qemuCaps->usedQMP) return 0; - if (virQEMUCapsProbeQMPCommands(caps, mon) < 0) + if (virQEMUCapsProbeQMPCommands(qemuCaps, mon) < 0) return -1; - if (virQEMUCapsProbeQMPEvents(caps, mon) < 0) + if (virQEMUCapsProbeQMPEvents(qemuCaps, mon) < 0) return -1; return 0; @@ -2176,7 +2176,7 @@ int virQEMUCapsProbeQMP(virQEMUCapsPtr caps, #define QEMU_SYSTEM_PREFIX "qemu-system-" static int -virQEMUCapsInitHelp(virQEMUCapsPtr caps, uid_t runUid, gid_t runGid) +virQEMUCapsInitHelp(virQEMUCapsPtr qemuCaps, uid_t runUid, gid_t runGid) { virCommandPtr cmd = NULL; unsigned int is_kvm; @@ -2185,55 +2185,55 @@ virQEMUCapsInitHelp(virQEMUCapsPtr caps, uid_t runUid, gid_t runGid) const char *tmp; virQEMUCapsHookData hookData; - VIR_DEBUG("caps=%p", caps); + VIR_DEBUG("qemuCaps=%p", qemuCaps); - tmp = strstr(caps->binary, QEMU_SYSTEM_PREFIX); + tmp = strstr(qemuCaps->binary, QEMU_SYSTEM_PREFIX); if (tmp) { tmp += strlen(QEMU_SYSTEM_PREFIX); - caps->arch = virQEMUCapsArchFromString(tmp); + qemuCaps->arch = virQEMUCapsArchFromString(tmp); } else { - caps->arch = virArchFromHost(); + qemuCaps->arch = virArchFromHost(); } hookData.runUid = runUid; hookData.runGid = runGid; - cmd = virQEMUCapsProbeCommand(caps->binary, NULL, &hookData); + cmd = virQEMUCapsProbeCommand(qemuCaps->binary, NULL, &hookData); virCommandAddArgList(cmd, "-help", NULL); virCommandSetOutputBuffer(cmd, &help); if (virCommandRun(cmd, NULL) < 0) goto cleanup; - if (virQEMUCapsParseHelpStr(caps->binary, - help, caps, - &caps->version, - &is_kvm, - &caps->kvmVersion, - false) < 0) + if (virQEMUCapsParseHelpStr(qemuCaps->binary, + help, qemuCaps, + &qemuCaps->version, + &is_kvm, + &qemuCaps->kvmVersion, + false) < 0) goto cleanup; /* Currently only x86_64 and i686 support PCI-multibus. */ - if (caps->arch == VIR_ARCH_X86_64 || - caps->arch == VIR_ARCH_I686) { - virQEMUCapsSet(caps, QEMU_CAPS_PCI_MULTIBUS); + if (qemuCaps->arch == VIR_ARCH_X86_64 || + qemuCaps->arch == VIR_ARCH_I686) { + virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS); } else { /* -no-acpi is not supported on other archs * even if qemu reports it in -help */ - virQEMUCapsClear(caps, QEMU_CAPS_NO_ACPI); + virQEMUCapsClear(qemuCaps, QEMU_CAPS_NO_ACPI); } /* virQEMUCapsExtractDeviceStr will only set additional caps if qemu * understands the 0.13.0+ notion of "-device driver,". */ - if (virQEMUCapsGet(caps, QEMU_CAPS_DEVICE) && + if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE) && strstr(help, "-device driver,?") && - virQEMUCapsExtractDeviceStr(caps->binary, caps, &hookData) < 0) + virQEMUCapsExtractDeviceStr(qemuCaps->binary, qemuCaps, &hookData) < 0) goto cleanup; - if (virQEMUCapsProbeCPUModels(caps, &hookData) < 0) + if (virQEMUCapsProbeCPUModels(qemuCaps, &hookData) < 0) goto cleanup; - if (virQEMUCapsProbeMachineTypes(caps, &hookData) < 0) + if (virQEMUCapsProbeMachineTypes(qemuCaps, &hookData) < 0) goto cleanup; ret = 0; @@ -2259,62 +2259,62 @@ static qemuMonitorCallbacks callbacks = { * for QEMU >= 1.2.0 */ static void -virQEMUCapsInitQMPBasic(virQEMUCapsPtr caps) +virQEMUCapsInitQMPBasic(virQEMUCapsPtr qemuCaps) { - virQEMUCapsSet(caps, QEMU_CAPS_VNC_COLON); - virQEMUCapsSet(caps, QEMU_CAPS_NO_REBOOT); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE); - virQEMUCapsSet(caps, QEMU_CAPS_NAME); - virQEMUCapsSet(caps, QEMU_CAPS_UUID); - virQEMUCapsSet(caps, QEMU_CAPS_VNET_HDR); - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP); - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_V2); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_FORMAT); - virQEMUCapsSet(caps, QEMU_CAPS_VGA); - virQEMUCapsSet(caps, QEMU_CAPS_0_10); - virQEMUCapsSet(caps, QEMU_CAPS_MEM_PATH); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_SERIAL); - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_UNIX); - virQEMUCapsSet(caps, QEMU_CAPS_CHARDEV); - virQEMUCapsSet(caps, QEMU_CAPS_MONITOR_JSON); - virQEMUCapsSet(caps, QEMU_CAPS_BALLOON); - virQEMUCapsSet(caps, QEMU_CAPS_DEVICE); - virQEMUCapsSet(caps, QEMU_CAPS_SDL); - virQEMUCapsSet(caps, QEMU_CAPS_SMP_TOPOLOGY); - virQEMUCapsSet(caps, QEMU_CAPS_NETDEV); - virQEMUCapsSet(caps, QEMU_CAPS_RTC); - virQEMUCapsSet(caps, QEMU_CAPS_VHOST_NET); - virQEMUCapsSet(caps, QEMU_CAPS_NO_HPET); - virQEMUCapsSet(caps, QEMU_CAPS_NODEFCONFIG); - virQEMUCapsSet(caps, QEMU_CAPS_BOOT_MENU); - virQEMUCapsSet(caps, QEMU_CAPS_FSDEV); - virQEMUCapsSet(caps, QEMU_CAPS_NAME_PROCESS); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_READONLY); - virQEMUCapsSet(caps, QEMU_CAPS_SMBIOS_TYPE); - virQEMUCapsSet(caps, QEMU_CAPS_VGA_NONE); - virQEMUCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_FD); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_AIO); - virQEMUCapsSet(caps, QEMU_CAPS_CHARDEV_SPICEVMC); - virQEMUCapsSet(caps, QEMU_CAPS_DEVICE_QXL_VGA); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC); - virQEMUCapsSet(caps, QEMU_CAPS_NO_SHUTDOWN); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_UNSAFE); - virQEMUCapsSet(caps, QEMU_CAPS_FSDEV_READONLY); - virQEMUCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_SG_IO); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_COPY_ON_READ); - virQEMUCapsSet(caps, QEMU_CAPS_CPU_HOST); - virQEMUCapsSet(caps, QEMU_CAPS_FSDEV_WRITEOUT); - virQEMUCapsSet(caps, QEMU_CAPS_DRIVE_IOTUNE); - virQEMUCapsSet(caps, QEMU_CAPS_WAKEUP); - virQEMUCapsSet(caps, QEMU_CAPS_NO_USER_CONFIG); - virQEMUCapsSet(caps, QEMU_CAPS_NETDEV_BRIDGE); - virQEMUCapsSet(caps, QEMU_CAPS_SECCOMP_SANDBOX); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_COLON); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_REBOOT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_UUID); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNET_HDR); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_0_10); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MEM_PATH); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_BALLOON); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOST_NET); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NODEFCONFIG); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_BOOT_MENU); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME_PROCESS); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_READONLY); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_NONE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_AIO); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_READONLY); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_HOST); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_WAKEUP); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX); } static int -virQEMUCapsInitQMP(virQEMUCapsPtr caps, +virQEMUCapsInitQMP(virQEMUCapsPtr qemuCaps, const char *libDir, uid_t runUid, gid_t runGid) @@ -2362,7 +2362,7 @@ virQEMUCapsInitQMP(virQEMUCapsPtr caps, config.data.nix.path = monpath; config.data.nix.listen = false; - VIR_DEBUG("Try to get caps via QMP caps=%p", caps); + VIR_DEBUG("Try to get caps via QMP qemuCaps=%p", qemuCaps); /* * We explicitly need to use -daemonize here, rather than @@ -2371,7 +2371,7 @@ virQEMUCapsInitQMP(virQEMUCapsPtr caps, * daemonize guarantees control won't return to libvirt * until the socket is present. */ - cmd = virCommandNewArgList(caps->binary, + cmd = virCommandNewArgList(qemuCaps->binary, "-S", "-no-user-config", "-nodefaults", @@ -2392,7 +2392,7 @@ virQEMUCapsInitQMP(virQEMUCapsPtr caps, if (status != 0) { ret = 0; - VIR_DEBUG("QEMU %s exited with status %d", caps->binary, status); + VIR_DEBUG("QEMU %s exited with status %d", qemuCaps->binary, status); goto cleanup; } @@ -2439,15 +2439,15 @@ virQEMUCapsInitQMP(virQEMUCapsPtr caps, goto cleanup; } - caps->version = major * 1000000 + minor * 1000 + micro; - caps->usedQMP = true; + qemuCaps->version = major * 1000000 + minor * 1000 + micro; + qemuCaps->usedQMP = true; - virQEMUCapsInitQMPBasic(caps); + virQEMUCapsInitQMPBasic(qemuCaps); if (!(archstr = qemuMonitorGetTargetArch(mon))) goto cleanup; - if ((caps->arch = virQEMUCapsArchFromString(archstr)) == VIR_ARCH_NONE) { + if ((qemuCaps->arch = virQEMUCapsArchFromString(archstr)) == VIR_ARCH_NONE) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Unknown QEMU arch %s"), archstr); VIR_FREE(archstr); @@ -2456,23 +2456,23 @@ virQEMUCapsInitQMP(virQEMUCapsPtr caps, VIR_FREE(archstr); /* Currently only x86_64 and i686 support PCI-multibus and -no-acpi. */ - if (caps->arch == VIR_ARCH_X86_64 || - caps->arch == VIR_ARCH_I686) { - virQEMUCapsSet(caps, QEMU_CAPS_PCI_MULTIBUS); - virQEMUCapsSet(caps, QEMU_CAPS_NO_ACPI); + if (qemuCaps->arch == VIR_ARCH_X86_64 || + qemuCaps->arch == VIR_ARCH_I686) { + virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS); + virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI); } - if (virQEMUCapsProbeQMPCommands(caps, mon) < 0) + if (virQEMUCapsProbeQMPCommands(qemuCaps, mon) < 0) goto cleanup; - if (virQEMUCapsProbeQMPEvents(caps, mon) < 0) + if (virQEMUCapsProbeQMPEvents(qemuCaps, mon) < 0) goto cleanup; - if (virQEMUCapsProbeQMPObjects(caps, mon) < 0) + if (virQEMUCapsProbeQMPObjects(qemuCaps, mon) < 0) goto cleanup; - if (virQEMUCapsProbeQMPMachineTypes(caps, mon) < 0) + if (virQEMUCapsProbeQMPMachineTypes(qemuCaps, mon) < 0) goto cleanup; - if (virQEMUCapsProbeQMPCPUDefinitions(caps, mon) < 0) + if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, mon) < 0) goto cleanup; - if (virQEMUCapsProbeQMPKVMState(caps, mon) < 0) + if (virQEMUCapsProbeQMPKVMState(qemuCaps, mon) < 0) goto cleanup; ret = 0; @@ -2509,11 +2509,11 @@ virQEMUCapsPtr virQEMUCapsNewForBinary(const char *binary, uid_t runUid, gid_t runGid) { - virQEMUCapsPtr caps = virQEMUCapsNew(); + virQEMUCapsPtr qemuCaps = virQEMUCapsNew(); struct stat sb; int rv; - if (!(caps->binary = strdup(binary))) + if (!(qemuCaps->binary = strdup(binary))) goto no_memory; /* We would also want to check faccessat if we cared about ACLs, @@ -2523,7 +2523,7 @@ virQEMUCapsPtr virQEMUCapsNewForBinary(const char *binary, binary); goto error; } - caps->mtime = sb.st_mtime; + qemuCaps->mtime = sb.st_mtime; /* Make sure the binary we are about to try exec'ing exists. * Technically we could catch the exec() failure, but that's @@ -2535,35 +2535,35 @@ virQEMUCapsPtr virQEMUCapsNewForBinary(const char *binary, goto error; } - if ((rv = virQEMUCapsInitQMP(caps, libDir, runUid, runGid)) < 0) + if ((rv = virQEMUCapsInitQMP(qemuCaps, libDir, runUid, runGid)) < 0) goto error; - if (!caps->usedQMP && - virQEMUCapsInitHelp(caps, runUid, runGid) < 0) + if (!qemuCaps->usedQMP && + virQEMUCapsInitHelp(qemuCaps, runUid, runGid) < 0) goto error; - return caps; + return qemuCaps; no_memory: virReportOOMError(); error: - virObjectUnref(caps); - caps = NULL; + virObjectUnref(qemuCaps); + qemuCaps = NULL; return NULL; } -bool virQEMUCapsIsValid(virQEMUCapsPtr caps) +bool virQEMUCapsIsValid(virQEMUCapsPtr qemuCaps) { struct stat sb; - if (!caps->binary) + if (!qemuCaps->binary) return true; - if (stat(caps->binary, &sb) < 0) + if (stat(qemuCaps->binary, &sb) < 0) return false; - return sb.st_mtime == caps->mtime; + return sb.st_mtime == qemuCaps->mtime; } @@ -2576,8 +2576,8 @@ virQEMUCapsHashDataFree(void *payload, const void *key ATTRIBUTE_UNUSED) virQEMUCapsCachePtr virQEMUCapsCacheNew(const char *libDir, - uid_t runUid, - gid_t runGid) + uid_t runUid, + gid_t runGid) { virQEMUCapsCachePtr cache; @@ -2628,7 +2628,7 @@ virQEMUCapsCacheLookup(virQEMUCapsCachePtr cache, const char *binary) VIR_DEBUG("Creating capabilities for %s", binary); ret = virQEMUCapsNewForBinary(binary, cache->libDir, - cache->runUid, cache->runGid); + cache->runUid, cache->runGid); if (ret) { VIR_DEBUG("Caching capabilities %p for %s", ret, binary); @@ -2648,14 +2648,14 @@ virQEMUCapsCacheLookup(virQEMUCapsCachePtr cache, const char *binary) virQEMUCapsPtr virQEMUCapsCacheLookupCopy(virQEMUCapsCachePtr cache, const char *binary) { - virQEMUCapsPtr caps = virQEMUCapsCacheLookup(cache, binary); + virQEMUCapsPtr qemuCaps = virQEMUCapsCacheLookup(cache, binary); virQEMUCapsPtr ret; - if (!caps) + if (!qemuCaps) return NULL; - ret = virQEMUCapsNewCopy(caps); - virObjectUnref(caps); + ret = virQEMUCapsNewCopy(qemuCaps); + virObjectUnref(qemuCaps); return ret; } @@ -2673,7 +2673,7 @@ virQEMUCapsCacheFree(virQEMUCapsCachePtr cache) } bool -virQEMUCapsUsedQMP(virQEMUCapsPtr caps) +virQEMUCapsUsedQMP(virQEMUCapsPtr qemuCaps) { - return caps->usedQMP; + return qemuCaps->usedQMP; } diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index e632615..8e7c09c 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -1625,10 +1625,10 @@ qemuProcessLookupPTYs(virDomainChrDefPtr *devices, static int qemuProcessFindCharDevicePTYsMonitor(virDomainObjPtr vm, - virQEMUCapsPtr caps, + virQEMUCapsPtr qemuCaps, virHashTablePtr paths) { - bool chardevfmt = virQEMUCapsGet(caps, QEMU_CAPS_CHARDEV); + bool chardevfmt = virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV); int i = 0; if (qemuProcessLookupPTYs(vm->def->serials, vm->def->nserials, @@ -1753,7 +1753,7 @@ qemuProcessReadLogFD(int logfd, char *buf, int maxlen, int off) static int qemuProcessWaitForMonitor(virQEMUDriverPtr driver, virDomainObjPtr vm, - virQEMUCapsPtr caps, + virQEMUCapsPtr qemuCaps, off_t pos) { char *buf = NULL; @@ -1763,7 +1763,7 @@ qemuProcessWaitForMonitor(virQEMUDriverPtr driver, virHashTablePtr paths = NULL; qemuDomainObjPrivatePtr priv; - if (!virQEMUCapsUsedQMP(caps) && pos != -1) { + if (!virQEMUCapsUsedQMP(qemuCaps) && pos != -1) { if ((logfd = qemuDomainOpenLog(driver, vm, pos)) < 0) return -1; @@ -1798,7 +1798,7 @@ qemuProcessWaitForMonitor(virQEMUDriverPtr driver, VIR_DEBUG("qemuMonitorGetPtyPaths returned %i", ret); if (ret == 0) - ret = qemuProcessFindCharDevicePTYsMonitor(vm, caps, paths); + ret = qemuProcessFindCharDevicePTYsMonitor(vm, qemuCaps, paths); cleanup: virHashFree(paths); @@ -1806,7 +1806,7 @@ cleanup: if (pos != -1 && kill(vm->pid, 0) == -1 && errno == ESRCH) { /* VM is dead, any other error raised in the interim is probably * not as important as the qemu cmdline output */ - if (virQEMUCapsUsedQMP(caps)) { + if (virQEMUCapsUsedQMP(qemuCaps)) { if ((logfd = qemuDomainOpenLog(driver, vm, pos)) < 0) return -1; diff --git a/tests/qemuhelptest.c b/tests/qemuhelptest.c index f5b37d5..720a188 100644 --- a/tests/qemuhelptest.c +++ b/tests/qemuhelptest.c @@ -53,7 +53,7 @@ static int testHelpStrParsing(const void *data) goto cleanup; if (virQEMUCapsParseHelpStr("QEMU", help, flags, - &version, &is_kvm, &kvm_version, false) == -1) + &version, &is_kvm, &kvm_version, false) == -1) goto cleanup; # ifndef WITH_YAJL -- |: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|