[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

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



On Wed, Feb 06, 2013 at 04:30:18PM +0100, Jiri Denemark wrote:
> On Wed, Feb 06, 2013 at 11:54:50 +0000, Daniel P. Berrange wrote:
> > From: "Daniel P. Berrange" <berrange redhat com>
> > 
> > To avoid confusion between 'virCapsPtr' and 'qemuCapsPtr'
> > do some renaming of various.
> 
> Sounds like you wanted to say something more or forgot to delete "to
> various".
> 
> > All instances of 'qemuCapsPtr'
> > are renamed to 'qemuCaps'. To avoid that clashing with
> > the 'qemuCaps' typedef though, rename the latter to
> > virQEMUCaps.
> > ---
> >  src/qemu/qemu_capabilities.c | 860 +++++++++++++++++++++----------------------
> >  src/qemu/qemu_capabilities.h | 114 +++---
> >  src/qemu/qemu_command.c      | 648 ++++++++++++++++----------------
> >  src/qemu/qemu_command.h      |  60 +--
> >  src/qemu/qemu_conf.h         |   2 +-
> >  src/qemu/qemu_domain.c       |  20 +-
> >  src/qemu/qemu_domain.h       |   2 +-
> >  src/qemu/qemu_driver.c       | 130 +++----
> >  src/qemu/qemu_hotplug.c      | 138 +++----
> >  src/qemu/qemu_migration.c    |  18 +-
> >  src/qemu/qemu_process.c      |  70 ++--
> >  tests/qemuhelptest.c         |  32 +-
> >  tests/qemuxml2argvtest.c     |  32 +-
> >  tests/qemuxmlnstest.c        |  24 +-
> >  14 files changed, 1076 insertions(+), 1074 deletions(-)
> 
> I'm not sure if it was intentional or not but the rename of all
> qemuCapsPtr (now virQEMUCapsPtr) to qemuCaps is incomplete. Lots of
> missed instances can be found in src/qemu/qemu_capabilities.[ch] and two
> of them remained in src/qemu/qemu_process.c.

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 :|


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]