qemu: Use helper functions for handling cmd line capabilities

Three new functions (qemuCapsSet, qemuCapsClear, and qemuCapsGet) were
introduced replacing direct bit operations.

src/qemu/qemu_capabilities.c

@@ -400,7 +400,7 @@ qemuCapsProbeCPUModels(const char *qemu,
     }
 
     cmd = virCommandNewArgList(qemu, "-cpu", "?", NULL);
-    if (qemuCmdFlags & QEMU_CAPS_NODEFCONFIG)
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_NODEFCONFIG))
         virCommandAddArg(cmd, "-nodefconfig");
     virCommandAddEnvPassCommon(cmd);
     virCommandSetOutputBuffer(cmd, &output);
@@ -559,7 +559,7 @@ qemuCapsInitGuest(virCapsPtr caps,
         goto error;
 
     if (qemuCapsExtractVersionInfo(binary, info->arch, NULL, &qemuCmdFlags) < 0 ||
-        ((qemuCmdFlags & QEMU_CAPS_BOOTINDEX) &&
+        (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_BOOTINDEX) &&
          !virCapabilitiesAddGuestFeature(guest, "deviceboot", 1, 0)))
         goto error;
 
@@ -791,119 +791,119 @@ qemuCapsComputeCmdFlags(const char *help,
     const char *p;
 
     if (strstr(help, "-no-kqemu"))
-        flags |= QEMU_CAPS_KQEMU;
+        qemuCapsSet(&flags, QEMU_CAPS_KQEMU);
     if (strstr(help, "-enable-kqemu"))
-        flags |= QEMU_CAPS_ENABLE_KQEMU;
+        qemuCapsSet(&flags, QEMU_CAPS_ENABLE_KQEMU);
     if (strstr(help, "-no-kvm"))
-        flags |= QEMU_CAPS_KVM;
+        qemuCapsSet(&flags, QEMU_CAPS_KVM);
     if (strstr(help, "-enable-kvm"))
-        flags |= QEMU_CAPS_ENABLE_KVM;
+        qemuCapsSet(&flags, QEMU_CAPS_ENABLE_KVM);
     if (strstr(help, "-no-reboot"))
-        flags |= QEMU_CAPS_NO_REBOOT;
+        qemuCapsSet(&flags, QEMU_CAPS_NO_REBOOT);
     if (strstr(help, "-name")) {
-        flags |= QEMU_CAPS_NAME;
+        qemuCapsSet(&flags, QEMU_CAPS_NAME);
         if (strstr(help, ",process="))
-            flags |= QEMU_CAPS_NAME_PROCESS;
+            qemuCapsSet(&flags, QEMU_CAPS_NAME_PROCESS);
     }
     if (strstr(help, "-uuid"))
-        flags |= QEMU_CAPS_UUID;
+        qemuCapsSet(&flags, QEMU_CAPS_UUID);
     if (strstr(help, "-xen-domid"))
-        flags |= QEMU_CAPS_XEN_DOMID;
+        qemuCapsSet(&flags, QEMU_CAPS_XEN_DOMID);
     else if (strstr(help, "-domid"))
-        flags |= QEMU_CAPS_DOMID;
+        qemuCapsSet(&flags, QEMU_CAPS_DOMID);
     if (strstr(help, "-drive")) {
-        flags |= QEMU_CAPS_DRIVE;
+        qemuCapsSet(&flags, QEMU_CAPS_DRIVE);
         if (strstr(help, "cache=") &&
             !strstr(help, "cache=on|off"))
-            flags |= QEMU_CAPS_DRIVE_CACHE_V2;
+            qemuCapsSet(&flags, QEMU_CAPS_DRIVE_CACHE_V2);
         if (strstr(help, "format="))
-            flags |= QEMU_CAPS_DRIVE_FORMAT;
+            qemuCapsSet(&flags, QEMU_CAPS_DRIVE_FORMAT);
         if (strstr(help, "readonly="))
-            flags |= QEMU_CAPS_DRIVE_READONLY;
+            qemuCapsSet(&flags, QEMU_CAPS_DRIVE_READONLY);
         if (strstr(help, "aio=threads|native"))
-            flags |= QEMU_CAPS_DRIVE_AIO;
+            qemuCapsSet(&flags, QEMU_CAPS_DRIVE_AIO);
     }
     if ((p = strstr(help, "-vga")) && !strstr(help, "-std-vga")) {
         const char *nl = strstr(p, "\n");
 
-        flags |= QEMU_CAPS_VGA;
+        qemuCapsSet(&flags, QEMU_CAPS_VGA);
 
         if (strstr(p, "|qxl"))
-            flags |= QEMU_CAPS_VGA_QXL;
+            qemuCapsSet(&flags, QEMU_CAPS_VGA_QXL);
         if ((p = strstr(p, "|none")) && p < nl)
-            flags |= QEMU_CAPS_VGA_NONE;
+            qemuCapsSet(&flags, QEMU_CAPS_VGA_NONE);
     }
     if (strstr(help, "-spice"))
-        flags |= QEMU_CAPS_SPICE;
+        qemuCapsSet(&flags, QEMU_CAPS_SPICE);
     if (strstr(help, "boot=on"))
-        flags |= QEMU_CAPS_DRIVE_BOOT;
+        qemuCapsSet(&flags, QEMU_CAPS_DRIVE_BOOT);
     if (strstr(help, "serial=s"))
-        flags |= QEMU_CAPS_DRIVE_SERIAL;
+        qemuCapsSet(&flags, QEMU_CAPS_DRIVE_SERIAL);
     if (strstr(help, "-pcidevice"))
-        flags |= QEMU_CAPS_PCIDEVICE;
+        qemuCapsSet(&flags, QEMU_CAPS_PCIDEVICE);
     if (strstr(help, "-mem-path"))
-        flags |= QEMU_CAPS_MEM_PATH;
+        qemuCapsSet(&flags, QEMU_CAPS_MEM_PATH);
     if (strstr(help, "-chardev")) {
-        flags |= QEMU_CAPS_CHARDEV;
+        qemuCapsSet(&flags, QEMU_CAPS_CHARDEV);
         if (strstr(help, "-chardev spicevmc"))
-            flags |= QEMU_CAPS_CHARDEV_SPICEVMC;
+            qemuCapsSet(&flags, QEMU_CAPS_CHARDEV_SPICEVMC);
     }
     if (strstr(help, "-balloon"))
-        flags |= QEMU_CAPS_BALLOON;
+        qemuCapsSet(&flags, QEMU_CAPS_BALLOON);
     if (strstr(help, "-device")) {
-        flags |= QEMU_CAPS_DEVICE;
+        qemuCapsSet(&flags, QEMU_CAPS_DEVICE);
         /*
          * When -device was introduced, qemu already supported drive's
          * readonly option but didn't advertise that.
          */
-        flags |= QEMU_CAPS_DRIVE_READONLY;
+        qemuCapsSet(&flags, QEMU_CAPS_DRIVE_READONLY);
     }
     if (strstr(help, "-nodefconfig"))
-        flags |= QEMU_CAPS_NODEFCONFIG;
+        qemuCapsSet(&flags, QEMU_CAPS_NODEFCONFIG);
     /* The trailing ' ' is important to avoid a bogus match */
     if (strstr(help, "-rtc "))
-        flags |= QEMU_CAPS_RTC;
+        qemuCapsSet(&flags, QEMU_CAPS_RTC);
     /* to wit */
     if (strstr(help, "-rtc-td-hack"))
-        flags |= QEMU_CAPS_RTC_TD_HACK;
+        qemuCapsSet(&flags, QEMU_CAPS_RTC_TD_HACK);
     if (strstr(help, "-no-hpet"))
-        flags |= QEMU_CAPS_NO_HPET;
+        qemuCapsSet(&flags, QEMU_CAPS_NO_HPET);
     if (strstr(help, "-no-kvm-pit-reinjection"))
-        flags |= QEMU_CAPS_NO_KVM_PIT;
+        qemuCapsSet(&flags, QEMU_CAPS_NO_KVM_PIT);
     if (strstr(help, "-tdf"))
-        flags |= QEMU_CAPS_TDF;
+        qemuCapsSet(&flags, QEMU_CAPS_TDF);
     if (strstr(help, "-enable-nesting"))
-        flags |= QEMU_CAPS_NESTING;
+        qemuCapsSet(&flags, QEMU_CAPS_NESTING);
     if (strstr(help, ",menu=on"))
-        flags |= QEMU_CAPS_BOOT_MENU;
+        qemuCapsSet(&flags, QEMU_CAPS_BOOT_MENU);
     if (strstr(help, "-fsdev"))
-        flags |= QEMU_CAPS_FSDEV;
+        qemuCapsSet(&flags, QEMU_CAPS_FSDEV);
     if (strstr(help, "-smbios type"))
-        flags |= QEMU_CAPS_SMBIOS_TYPE;
+        qemuCapsSet(&flags, QEMU_CAPS_SMBIOS_TYPE);
 
     if (strstr(help, "-netdev")) {
         /* Disable -netdev on 0.12 since although it exists,
          * the corresponding netdev_add/remove monitor commands
          * do not, and we need them to be able todo hotplug */
         if (version >= 13000)
-            flags |= QEMU_CAPS_NETDEV;
+            qemuCapsSet(&flags, QEMU_CAPS_NETDEV);
     }
 
     if (strstr(help, "-sdl"))
-        flags |= QEMU_CAPS_SDL;
+        qemuCapsSet(&flags, QEMU_CAPS_SDL);
     if (strstr(help, "cores=") &&
         strstr(help, "threads=") &&
         strstr(help, "sockets="))
-        flags |= QEMU_CAPS_SMP_TOPOLOGY;
+        qemuCapsSet(&flags, QEMU_CAPS_SMP_TOPOLOGY);
 
     if (version >= 9000)
-        flags |= QEMU_CAPS_VNC_COLON;
+        qemuCapsSet(&flags, QEMU_CAPS_VNC_COLON);
 
     if (is_kvm && (version >= 10000 || kvm_version >= 74))
-        flags |= QEMU_CAPS_VNET_HDR;
+        qemuCapsSet(&flags, QEMU_CAPS_VNET_HDR);
 
     if (is_kvm && strstr(help, ",vhost=")) {
-        flags |= QEMU_CAPS_VNET_HOST;
+        qemuCapsSet(&flags, QEMU_CAPS_VNET_HOST);
     }
 
     /*
@@ -919,22 +919,22 @@ qemuCapsComputeCmdFlags(const char *help,
      * while waiting for data, so pretend it doesn't exist
      */
     if (version >= 10000) {
-        flags |= QEMU_CAPS_MIGRATE_QEMU_TCP;
-        flags |= QEMU_CAPS_MIGRATE_QEMU_EXEC;
+        qemuCapsSet(&flags, QEMU_CAPS_MIGRATE_QEMU_TCP);
+        qemuCapsSet(&flags, QEMU_CAPS_MIGRATE_QEMU_EXEC);
         if (version >= 12000) {
-            flags |= QEMU_CAPS_MIGRATE_QEMU_UNIX;
-            flags |= QEMU_CAPS_MIGRATE_QEMU_FD;
+            qemuCapsSet(&flags, QEMU_CAPS_MIGRATE_QEMU_UNIX);
+            qemuCapsSet(&flags, QEMU_CAPS_MIGRATE_QEMU_FD);
         }
     } else if (kvm_version >= 79) {
-        flags |= QEMU_CAPS_MIGRATE_QEMU_TCP;
+        qemuCapsSet(&flags, QEMU_CAPS_MIGRATE_QEMU_TCP);
         if (kvm_version >= 80)
-            flags |= QEMU_CAPS_MIGRATE_QEMU_EXEC;
+            qemuCapsSet(&flags, QEMU_CAPS_MIGRATE_QEMU_EXEC);
     } else if (kvm_version > 0) {
-        flags |= QEMU_CAPS_MIGRATE_KVM_STDIO;
+        qemuCapsSet(&flags, QEMU_CAPS_MIGRATE_KVM_STDIO);
     }
 
     if (version >= 10000)
-        flags |= QEMU_CAPS_0_10;
+        qemuCapsSet(&flags, QEMU_CAPS_0_10);
 
     /* While JSON mode was available in 0.12.0, it was too
      * incomplete to contemplate using. The 0.13.0 release
@@ -943,7 +943,7 @@ qemuCapsComputeCmdFlags(const char *help,
      * the downside.
      */
      if (version >= 13000)
-        flags |= QEMU_CAPS_MONITOR_JSON;
+        qemuCapsSet(&flags, QEMU_CAPS_MONITOR_JSON);
 
     return flags;
 }
@@ -1098,26 +1098,26 @@ qemuCapsParseDeviceStr(const char *str, unsigned long long *flags)
 {
     /* Which devices exist. */
     if (strstr(str, "name \"hda-duplex\""))
-        *flags |= QEMU_CAPS_HDA_DUPLEX;
+        qemuCapsSet(flags, QEMU_CAPS_HDA_DUPLEX);
     if (strstr(str, "name \"ccid-card-emulated\""))
-        *flags |= QEMU_CAPS_CCID_EMULATED;
+        qemuCapsSet(flags, QEMU_CAPS_CCID_EMULATED);
     if (strstr(str, "name \"ccid-card-passthru\""))
-        *flags |= QEMU_CAPS_CCID_PASSTHRU;
+        qemuCapsSet(flags, QEMU_CAPS_CCID_PASSTHRU);
     /* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
-    if (!(*flags & QEMU_CAPS_CHARDEV_SPICEVMC) &&
+    if (!qemuCapsGet(*flags, QEMU_CAPS_CHARDEV_SPICEVMC) &&
         strstr(str, "name \"spicevmc\""))
-        *flags |= QEMU_CAPS_DEVICE_SPICEVMC;
+        qemuCapsSet(flags, QEMU_CAPS_DEVICE_SPICEVMC);
 
     /* Features of given devices. */
     if (strstr(str, "pci-assign.configfd"))
-        *flags |= QEMU_CAPS_PCI_CONFIGFD;
+        qemuCapsSet(flags, QEMU_CAPS_PCI_CONFIGFD);
     if (strstr(str, "virtio-blk-pci.bootindex")) {
-        *flags |= QEMU_CAPS_BOOTINDEX;
+        qemuCapsSet(flags, QEMU_CAPS_BOOTINDEX);
         if (strstr(str, "pci-assign.bootindex"))
-            *flags |= QEMU_CAPS_PCI_BOOTINDEX;
+            qemuCapsSet(flags, QEMU_CAPS_PCI_BOOTINDEX);
     }
     if (strstr(str, "virtio-net-pci.tx="))
-        *flags |= QEMU_CAPS_VIRTIO_TX_ALG;
+        qemuCapsSet(flags, QEMU_CAPS_VIRTIO_TX_ALG);
 
     return 0;
 }
@@ -1161,12 +1161,12 @@ int qemuCapsExtractVersionInfo(const char *qemu, const char *arch,
     /* Currently only x86_64 and i686 support PCI-multibus. */
     if (STREQLEN(arch, "x86_64", 6) ||
         STREQLEN(arch, "i686", 4)) {
-        flags |= QEMU_CAPS_PCI_MULTIBUS;
+        qemuCapsSet(&flags, QEMU_CAPS_PCI_MULTIBUS);
     }
 
     /* qemuCapsExtractDeviceStr will only set additional flags if qemu
      * understands the 0.13.0+ notion of "-device driver,".  */
-    if ((flags & QEMU_CAPS_DEVICE) &&
+    if (qemuCapsGet(flags, QEMU_CAPS_DEVICE) &&
         strstr(help, "-device driver,?") &&
         qemuCapsExtractDeviceStr(qemu, &flags) < 0)
         goto cleanup;
@@ -1231,3 +1231,27 @@ int qemuCapsExtractVersion(virCapsPtr caps,
 
     return 0;
 }
+
+
+void
+qemuCapsSet(unsigned long long *caps,
+            enum qemuCapsFlags flag)
+{
+    *caps |= flag;
+}
+
+
+void
+qemuCapsClear(unsigned long long *caps,
+              enum qemuCapsFlags flag)
+{
+    *caps &= ~flag;
+}
+
+
+bool
+qemuCapsGet(unsigned long long caps,
+            enum qemuCapsFlags flag)
+{
+    return !!(caps & flag);
+}

src/qemu/qemu_capabilities.h

@@ -95,6 +95,15 @@ enum qemuCapsFlags {
     QEMU_CAPS_VIRTIO_TX_ALG = (1LL << 58), /* -device virtio-net-pci,tx=string */
 };
 
+void qemuCapsSet(unsigned long long *caps,
+                 enum qemuCapsFlags flag);
+
+void qemuCapsClear(unsigned long long *caps,
+                   enum qemuCapsFlags flag);
+
+bool qemuCapsGet(unsigned long long caps,
+                 enum qemuCapsFlags flag);
+
 virCapsPtr qemuCapsInit(virCapsPtr old_caps);
 
 int qemuCapsProbeMachineTypes(const char *binary,

src/qemu/qemu_hotplug.c

@@ -160,7 +160,7 @@ int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver,
                                         vm, disk) < 0)
         return -1;
 
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0)
             goto error;
         if (qemuAssignDeviceDiskAlias(disk, qemuCmdFlags) < 0)
@@ -179,7 +179,7 @@ int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         ret = qemuMonitorAddDrive(priv->mon, drivestr);
         if (ret == 0) {
             ret = qemuMonitorAddDevice(priv->mon, devstr);
@@ -219,7 +219,7 @@ error:
     VIR_FREE(devstr);
     VIR_FREE(drivestr);
 
-    if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE) &&
         (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
         qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &disk->info) < 0)
         VIR_WARN("Unable to release PCI address on %s", disk->src);
@@ -253,7 +253,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
         }
     }
 
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0)
             goto cleanup;
         if (qemuAssignDeviceControllerAlias(controller) < 0)
@@ -270,7 +270,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         ret = qemuMonitorAddDevice(priv->mon, devstr);
     } else {
         ret = qemuMonitorAttachPCIDiskController(priv->mon,
@@ -286,7 +286,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
 
 cleanup:
     if ((ret != 0) &&
-        (qemuCmdFlags & QEMU_CAPS_DEVICE) &&
+        qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE) &&
         (controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
         qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &controller->info) < 0)
         VIR_WARN0("Unable to release PCI address on controller");
@@ -376,7 +376,7 @@ int qemuDomainAttachSCSIDisk(struct qemud_driver *driver,
         goto error;
     }
 
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuAssignDeviceDiskAlias(disk, qemuCmdFlags) < 0)
             goto error;
         if (!(devstr = qemuBuildDriveDevStr(disk, qemuCmdFlags)))
@@ -409,7 +409,7 @@ int qemuDomainAttachSCSIDisk(struct qemud_driver *driver,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         ret = qemuMonitorAddDrive(priv->mon, drivestr);
         if (ret == 0) {
             ret = qemuMonitorAddDevice(priv->mon, devstr);
@@ -487,7 +487,7 @@ int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver,
         goto error;
     }
 
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuAssignDeviceDiskAlias(disk, qemuCmdFlags) < 0)
             goto error;
         if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCmdFlags)))
@@ -502,7 +502,7 @@ int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         ret = qemuMonitorAddDrive(priv->mon, drivestr);
         if (ret == 0) {
             ret = qemuMonitorAddDevice(priv->mon, devstr);
@@ -558,7 +558,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
     virDomainDevicePCIAddress guestAddr;
     int vlan;
 
-    if (!(qemuCmdFlags & QEMU_CAPS_HOST_NET_ADD)) {
+    if (!qemuCapsGet(qemuCmdFlags, QEMU_CAPS_HOST_NET_ADD)) {
         qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                         _("installed qemu version does not support host_net_add"));
         return -1;
@@ -595,18 +595,18 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
     if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0)
         goto no_memory;
 
-    if ((qemuCmdFlags & QEMU_CAPS_NET_NAME) ||
-        (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_NET_NAME) ||
+        qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0)
             goto cleanup;
     }
 
-    if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE) &&
         qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0)
         goto cleanup;
 
-    if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
-        (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_NETDEV) &&
+        qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         vlan = -1;
     } else {
         vlan = qemuDomainNetVLAN(net);
@@ -637,8 +637,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
     }
 
     /* FIXME - need to support vhost-net here (5th arg) */
-    if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
-        (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_NETDEV) &&
+        qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (!(netstr = qemuBuildHostNetStr(net, ',',
                                            -1, tapfd_name, 0)))
             goto try_tapfd_close;
@@ -649,8 +649,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
-        (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_NETDEV) &&
+        qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuMonitorAddNetdev(priv->mon, netstr) < 0) {
             qemuDomainObjExitMonitorWithDriver(driver, vm);
             qemuDomainNetAudit(vm, NULL, net, "attach", false);
@@ -673,7 +673,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
         goto cleanup;
     }
 
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (!(nicstr = qemuBuildNicDevStr(net, vlan, qemuCmdFlags)))
             goto try_remove;
     } else {
@@ -682,7 +682,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) {
             qemuDomainObjExitMonitorWithDriver(driver, vm);
             qemuDomainNetAudit(vm, NULL, net, "attach", false);
@@ -708,7 +708,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
 
 cleanup:
     if ((ret != 0) &&
-        (qemuCmdFlags & QEMU_CAPS_DEVICE) &&
+        qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE) &&
         (net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
         qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &net->info) < 0)
         VIR_WARN0("Unable to release PCI address on NIC");
@@ -728,8 +728,8 @@ try_remove:
         goto cleanup;
 
     if (vlan < 0) {
-        if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
-            (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+        if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_NETDEV) &&
+            qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
             char *netdev_name;
             if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0)
                 goto no_memory;
@@ -793,12 +793,12 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
     if (qemuPrepareHostdevPCIDevices(driver, &hostdev, 1) < 0)
         return -1;
 
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
             goto error;
         if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &hostdev->info) < 0)
             goto error;
-        if (qemuCmdFlags & QEMU_CAPS_PCI_CONFIGFD) {
+        if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_PCI_CONFIGFD)) {
             configfd = qemuOpenPCIConfig(hostdev);
             if (configfd >= 0) {
                 if (virAsprintf(&configfd_name, "fd-%s",
@@ -854,7 +854,7 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
     return 0;
 
 error:
-    if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE) &&
         (hostdev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
         qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &hostdev->info) < 0)
         VIR_WARN0("Unable to release PCI address on host device");
@@ -878,7 +878,7 @@ int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
     qemuDomainObjPrivatePtr priv = vm->privateData;
     char *devstr = NULL;
 
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
             goto error;
         if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev)))
@@ -910,7 +910,7 @@ int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE)
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE))
         ret = qemuMonitorAddDevice(priv->mon, devstr);
     else
         ret = qemuMonitorAddUSBDeviceExact(priv->mon,
@@ -1173,7 +1173,7 @@ int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
             qemuDomainObjExitMonitor(vm);
             goto cleanup;
@@ -1193,7 +1193,7 @@ int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
 
     qemuDomainDiskAudit(vm, detach, NULL, "detach", ret >= 0);
 
-    if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE) &&
         qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
         VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src);
 
@@ -1237,7 +1237,7 @@ int qemuDomainDetachSCSIDiskDevice(struct qemud_driver *driver,
         goto cleanup;
     }
 
-    if (!(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+    if (!qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
                         _("Underlying qemu does not support SCSI disk removal"));
         goto cleanup;
@@ -1385,13 +1385,13 @@ int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
         goto cleanup;
     }
 
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuAssignDeviceControllerAlias(detach) < 0)
             goto cleanup;
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) {
             qemuDomainObjExitMonitor(vm);
             goto cleanup;
@@ -1419,7 +1419,7 @@ int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
         vm->def->ncontrollers = 0;
     }
 
-    if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE) &&
         qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
         VIR_WARN0("Unable to release PCI address on controller");
 
@@ -1479,7 +1479,7 @@ int qemuDomainDetachNetDevice(struct qemud_driver *driver,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
             qemuDomainObjExitMonitor(vm);
             qemuDomainNetAudit(vm, detach, NULL, "detach", false);
@@ -1494,8 +1494,8 @@ int qemuDomainDetachNetDevice(struct qemud_driver *driver,
         }
     }
 
-    if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
-        (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_NETDEV) &&
+        qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
             qemuDomainObjExitMonitorWithDriver(driver, vm);
             qemuDomainNetAudit(vm, detach, NULL, "detach", false);
@@ -1512,7 +1512,7 @@ int qemuDomainDetachNetDevice(struct qemud_driver *driver,
 
     qemuDomainNetAudit(vm, detach, NULL, "detach", true);
 
-    if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE) &&
         qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
         VIR_WARN0("Unable to release PCI address on NIC");
 
@@ -1605,7 +1605,7 @@ int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
     }
 
     qemuDomainObjEnterMonitorWithDriver(driver, vm);
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
             qemuDomainObjExitMonitor(vm);
             return -1;
@@ -1636,7 +1636,7 @@ int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
         pciFreeDevice(pci);
     }
 
-    if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE) &&
         qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
         VIR_WARN0("Unable to release PCI address on host device");
 
@@ -1707,7 +1707,7 @@ int qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
         return -1;
     }
 
-    if (!(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+    if (!qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         qemuReportError(VIR_ERR_OPERATION_FAILED,
                         "%s", _("device cannot be detached with this QEMU version"));
         return -1;

src/qemu/qemu_migration.c

@@ -304,9 +304,9 @@ qemuMigrationPrepareTunnel(struct qemud_driver *driver,
                         vm->def->emulator);
         goto endjob;
     }
-    if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_UNIX)
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_MIGRATE_QEMU_UNIX))
         internalret = virAsprintf(&migrateFrom, "unix:%s", unixfile);
-    else if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_EXEC)
+    else if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_MIGRATE_QEMU_EXEC))
         internalret = virAsprintf(&migrateFrom, "exec:nc -U -l %s", unixfile);
     else {
         qemuReportError(VIR_ERR_OPERATION_FAILED,
@@ -777,8 +777,8 @@ static int doTunnelMigrate(struct qemud_driver *driver,
         goto cleanup;
     }
 
-    if (!(qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
-        !(qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+    if (!qemuCapsGet(qemuCmdFlags, QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
+        !qemuCapsGet(qemuCmdFlags, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
         qemuReportError(VIR_ERR_OPERATION_FAILED,
                         "%s", _("Source qemu is too old to support tunnelled migration"));
         goto cleanup;
@@ -820,11 +820,11 @@ static int doTunnelMigrate(struct qemud_driver *driver,
         background_flags |= QEMU_MONITOR_MIGRATE_NON_SHARED_DISK;
     if (flags & VIR_MIGRATE_NON_SHARED_INC)
         background_flags |= QEMU_MONITOR_MIGRATE_NON_SHARED_INC;
-    if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_UNIX){
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
         internalret = qemuMonitorMigrateToUnix(priv->mon, background_flags,
                                                unixfile);
     }
-    else if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_EXEC) {
+    else if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
         const char *args[] = { "nc", "-U", unixfile, NULL };
         internalret = qemuMonitorMigrateToCommand(priv->mon, QEMU_MONITOR_MIGRATE_BACKGROUND, args);
     } else {

src/qemu/qemu_process.c

@@ -1159,7 +1159,7 @@ qemuProcessInitPasswords(virConnectPtr conn,
     if (ret < 0)
         goto cleanup;
 
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         int i;
 
         for (i = 0 ; i < vm->def->ndisks ; i++) {
@@ -1816,7 +1816,7 @@ qemuProcessReconnect(void *payload, const char *name ATTRIBUTE_UNUSED, void *opa
     if (qemuCapsExtractVersionInfo(obj->def->emulator, obj->def->os.arch,
                                    NULL,
                                    &qemuCmdFlags) >= 0 &&
-        (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+        qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         priv->persistentAddrs = 1;
 
         if (!(priv->pciaddrs = qemuDomainPCIAddressSetCreate(obj->def)) ||
@@ -2027,7 +2027,7 @@ int qemuProcessStart(virConnectPtr conn,
         goto cleanup;
 
 #if HAVE_YAJL
-    if (qemuCmdFlags & QEMU_CAPS_MONITOR_JSON)
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_MONITOR_JSON))
         priv->monJSON = 1;
     else
 #endif
@@ -2056,7 +2056,7 @@ int qemuProcessStart(virConnectPtr conn,
      * we also need to populate the PCi address set cache for later
      * use in hotplug
      */
-    if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         VIR_DEBUG0("Assigning domain PCI addresses");
         /* Populate cache with current addresses */
         if (priv->pciaddrs) {
@@ -2190,7 +2190,7 @@ int qemuProcessStart(virConnectPtr conn,
 
     /* If we have -device, then addresses are assigned explicitly.
      * If not, then we have to detect dynamic ones here */
-    if (!(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
+    if (!qemuCapsGet(qemuCmdFlags, QEMU_CAPS_DEVICE)) {
         VIR_DEBUG0("Determining domain device PCI addresses");
         if (qemuProcessInitPCIAddresses(driver, vm) < 0)
             goto cleanup;

tests/qemuhelptest.c

@@ -57,7 +57,7 @@ static int testHelpStrParsing(const void *data)
                              &version, &is_kvm, &kvm_version) == -1)
         goto cleanup;
 
-    if (info->flags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(info->flags, QEMU_CAPS_DEVICE)) {
         VIR_FREE(path);
         if (virAsprintf(&path, "%s/qemuhelpdata/%s-device", abs_srcdir,
                         info->name) < 0)

tests/qemuxml2argvtest.c

@@ -79,7 +79,7 @@ static int testCompareXMLToArgvFiles(const char *xml,
             goto fail;
     }
 
-    if (extraFlags & QEMU_CAPS_DOMID)
+    if (qemuCapsGet(extraFlags, QEMU_CAPS_DOMID))
         vmdef->id = 6;
     else
         vmdef->id = -1;
@@ -96,7 +96,7 @@ static int testCompareXMLToArgvFiles(const char *xml,
     if (qemudCanonicalizeMachine(&driver, vmdef) < 0)
         goto fail;
 
-    if (flags & QEMU_CAPS_DEVICE) {
+    if (qemuCapsGet(flags, QEMU_CAPS_DEVICE)) {
         qemuDomainPCIAddressSetPtr pciaddrs;
         if (!(pciaddrs = qemuDomainPCIAddressSetCreate(vmdef)))
             goto fail;
@@ -117,7 +117,7 @@ static int testCompareXMLToArgvFiles(const char *xml,
      */
     if (STREQLEN(vmdef->os.arch, "x86_64", 6) ||
         STREQLEN(vmdef->os.arch, "i686", 4)) {
-        flags |= QEMU_CAPS_PCI_MULTIBUS;
+        qemuCapsSet(&flags, QEMU_CAPS_PCI_MULTIBUS);
     }
 
     if (!(cmd = qemuBuildCommandLine(conn, &driver,