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

[libvirt] [PATCH] Deprecate several CURRENT/LIVE/CONFIG enums



This patch deprecates following enums:

VIR_DOMAIN_MEM_CURRENT
VIR_DOMAIN_MEM_LIVE
VIR_DOMAIN_MEM_CONFIG

VIR_DOMAIN_VCPU_LIVE
VIR_DOMAIN_VCPU_CONFIG

VIR_DOMAIN_DEVICE_MODIFY_CURRENT
VIR_DOMAIN_DEVICE_MODIFY_LIVE
VIR_DOMAIN_DEVICE_MODIFY_CONFIG

And modify internal codes to use virDomainModifycationImpact.
---
 include/libvirt/libvirt.h.in |   69 +++++++++++++++++++-------------
 python/generator.py          |    6 +++
 src/esx/esx_driver.c         |    8 ++--
 src/libvirt.c                |   36 ++++++++--------
 src/openvz/openvz_driver.c   |    8 ++--
 src/qemu/qemu_driver.c       |   90 +++++++++++++++++++++---------------------
 src/test/test_driver.c       |   32 +++++++-------
 src/uml/uml_driver.c         |    4 +-
 src/vbox/vbox_tmpl.c         |   20 +++++-----
 tools/virsh.c                |   52 ++++++++++++------------
 10 files changed, 172 insertions(+), 153 deletions(-)

diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index df213f1..d0378c4 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -863,15 +863,6 @@ int     virDomainGetMemoryParameters(virDomainPtr domain,
                                      virTypedParameterPtr params,
                                      int *nparams, unsigned int flags);
 
-/* Memory size modification flags. */
-typedef enum {
-    VIR_DOMAIN_MEM_CURRENT = 0,        /* affect current domain state */
-    VIR_DOMAIN_MEM_LIVE    = (1 << 0), /* affect active domain */
-    VIR_DOMAIN_MEM_CONFIG  = (1 << 1), /* affect next boot */
-    VIR_DOMAIN_MEM_MAXIMUM = (1 << 2), /* affect Max rather than current */
-} virDomainMemoryModFlags;
-
-
 /*
  * Dynamic control of domains
  */
@@ -1027,16 +1018,6 @@ struct _virVcpuInfo {
 };
 typedef virVcpuInfo *virVcpuInfoPtr;
 
-/* Flags for controlling virtual CPU hot-plugging.  */
-typedef enum {
-    /* Must choose at least one of these two bits; SetVcpus can choose both */
-    VIR_DOMAIN_VCPU_LIVE    = (1 << 0), /* Affect active domain */
-    VIR_DOMAIN_VCPU_CONFIG  = (1 << 1), /* Affect next boot */
-
-    /* Additional flags to be bit-wise OR'd in */
-    VIR_DOMAIN_VCPU_MAXIMUM = (1 << 2), /* Max rather than current count */
-} virDomainVcpuFlags;
-
 int                     virDomainSetVcpus       (virDomainPtr domain,
                                                  unsigned int nvcpus);
 int                     virDomainSetVcpusFlags  (virDomainPtr domain,
@@ -1136,15 +1117,6 @@ int                     virDomainGetVcpus       (virDomainPtr domain,
 #define VIR_GET_CPUMAP(cpumaps,maplen,vcpu)     &(cpumaps[(vcpu)*(maplen)])
 
 
-typedef enum {
-
-   VIR_DOMAIN_DEVICE_MODIFY_CURRENT = 0, /* Modify device allocation based on current domain state */
-   VIR_DOMAIN_DEVICE_MODIFY_LIVE = (1 << 0), /* Modify live device allocation */
-   VIR_DOMAIN_DEVICE_MODIFY_CONFIG = (1 << 1), /* Modify persisted device allocation */
-   VIR_DOMAIN_DEVICE_MODIFY_FORCE = (1 << 2), /* Forcibly modify device
-                                                 (ex. force eject a cdrom) */
-} virDomainDeviceModifyFlags;
-
 int virDomainAttachDevice(virDomainPtr domain, const char *xml);
 int virDomainDetachDevice(virDomainPtr domain, const char *xml);
 
@@ -2673,6 +2645,47 @@ typedef struct _virTypedParameter virMemoryParameter;
  */
 typedef virMemoryParameter *virMemoryParameterPtr;
 
+/* Memory size modification flags.
+ *
+ * Provided for backwards compatibility; virDomainModificationImpact is
+ * the preferred enum since 0.9.3.
+ */
+typedef enum {
+    VIR_DOMAIN_MEM_CURRENT = VIR_DOMAIN_AFFECT_CURRENT,
+    VIR_DOMAIN_MEM_LIVE    = VIR_DOMAIN_AFFECT_LIVE,
+    VIR_DOMAIN_MEM_CONFIG  = VIR_DOMAIN_AFFECT_CONFIG,
+
+    VIR_DOMAIN_MEM_MAXIMUM = (1 << 2), /* affect Max rather than current */
+} virDomainMemoryModFlags;
+
+/* Device modification flags.
+ *
+ * Provided for backwards compatibility; virDomainModificationImpact is
+ * the preferred enum since 0.9.3.
+ */
+typedef enum {
+   VIR_DOMAIN_DEVICE_MODIFY_CURRENT = VIR_DOMAIN_AFFECT_CURRENT,
+   VIR_DOMAIN_DEVICE_MODIFY_LIVE    = VIR_DOMAIN_AFFECT_LIVE,
+   VIR_DOMAIN_DEVICE_MODIFY_CONFIG  = VIR_DOMAIN_AFFECT_CONFIG,
+
+   VIR_DOMAIN_DEVICE_MODIFY_FORCE   = (1 << 2), /* Forcibly modify device
+                                                 (ex. force eject a cdrom) */
+} virDomainDeviceModifyFlags;
+
+/* Flags for controlling virtual CPU hot-plugging.
+ *
+ * Provided for backwards compatibility; virDomainModificationImpact is
+ * the preferred enum since 0.9.3.
+ */
+typedef enum {
+    /* Must choose at least one of these two bits; SetVcpus can choose both */
+    VIR_DOMAIN_VCPU_LIVE    = VIR_DOMAIN_AFFECT_LIVE,
+    VIR_DOMAIN_VCPU_CONFIG  = VIR_DOMAIN_AFFECT_CONFIG,
+
+    /* Additional flags to be bit-wise OR'd in */
+    VIR_DOMAIN_VCPU_MAXIMUM = (1 << 2), /* Max rather than current count */
+} virDomainVcpuFlags;
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/python/generator.py b/python/generator.py
index 7c38fdd..2cbe168 100755
--- a/python/generator.py
+++ b/python/generator.py
@@ -166,6 +166,12 @@ def enum(type, name, value):
         value = 5
     elif value == 'VIR_TYPED_PARAM_BOOLEAN':
         value = 6
+    elif value == 'VIR_DOMAIN_AFFECT_CURRENT':
+        value = 0
+    elif value == 'VIR_DOMAIN_AFFECT_LIVE':
+        value = 1
+    elif value == 'VIR_DOMAIN_AFFECT_CONFIG':
+        value = 2
     enums[type][name] = value
 
 #######################################################################
diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c
index a5b96a9..3a140e9 100644
--- a/src/esx/esx_driver.c
+++ b/src/esx/esx_driver.c
@@ -2535,7 +2535,7 @@ esxDomainSetVcpusFlags(virDomainPtr domain, unsigned int nvcpus,
     esxVI_TaskInfoState taskInfoState;
     char *taskInfoErrorMessage = NULL;
 
-    if (flags != VIR_DOMAIN_VCPU_LIVE) {
+    if (flags != VIR_DOMAIN_AFFECT_LIVE) {
         ESX_ERROR(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags);
         return -1;
     }
@@ -2606,7 +2606,7 @@ esxDomainSetVcpusFlags(virDomainPtr domain, unsigned int nvcpus,
 static int
 esxDomainSetVcpus(virDomainPtr domain, unsigned int nvcpus)
 {
-    return esxDomainSetVcpusFlags(domain, nvcpus, VIR_DOMAIN_VCPU_LIVE);
+    return esxDomainSetVcpusFlags(domain, nvcpus, VIR_DOMAIN_AFFECT_LIVE);
 }
 
 
@@ -2619,7 +2619,7 @@ esxDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
     esxVI_ObjectContent *hostSystem = NULL;
     esxVI_DynamicProperty *dynamicProperty = NULL;
 
-    if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) {
+    if (flags != (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) {
         ESX_ERROR(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags);
         return -1;
     }
@@ -2674,7 +2674,7 @@ esxDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
 static int
 esxDomainGetMaxVcpus(virDomainPtr domain)
 {
-    return esxDomainGetVcpusFlags(domain, (VIR_DOMAIN_VCPU_LIVE |
+    return esxDomainGetVcpusFlags(domain, (VIR_DOMAIN_AFFECT_LIVE |
                                            VIR_DOMAIN_VCPU_MAXIMUM));
 }
 
diff --git a/src/libvirt.c b/src/libvirt.c
index 18c4e08..463c033 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -2865,12 +2865,12 @@ error:
  * to Domain0 i.e. the domain where the application runs.
  * This function may requires privileged access to the hypervisor.
  *
- * @flags may include VIR_DOMAIN_MEM_LIVE or VIR_DOMAIN_MEM_CONFIG.
- * Both flags may be set. If VIR_DOMAIN_MEM_LIVE is set, the change affects
+ * @flags may include VIR_DOMAIN_AFFECT_LIVE or VIR_DOMAIN_AFFECT_CONFIG.
+ * Both flags may be set. If VIR_DOMAIN_AFFECT_LIVE is set, the change affects
  * a running domain and will fail if domain is not active.
- * If VIR_DOMAIN_MEM_CONFIG is set, the change affects persistent state,
+ * If VIR_DOMAIN_AFFECT_CONFIG is set, the change affects persistent state,
  * and will fail for transient domains. If neither flag is specified
- * (that is, @flags is VIR_DOMAIN_MEM_CURRENT), then an inactive domain
+ * (that is, @flags is VIR_DOMAIN_AFFECT_CURRENT), then an inactive domain
  * modifies persistent setup, while an active domain is hypervisor-dependent
  * on whether just live or both live and persistent state is changed.
  * If VIR_DOMAIN_MEM_MAXIMUM is set, the change affects domain's maximum memory
@@ -6514,13 +6514,13 @@ error:
  * does not support it or if growing the number is arbitrary limited.
  * This function requires privileged access to the hypervisor.
  *
- * @flags must include VIR_DOMAIN_VCPU_LIVE to affect a running
+ * @flags must include VIR_DOMAIN_AFFECT_LIVE to affect a running
  * domain (which may fail if domain is not active), or
- * VIR_DOMAIN_VCPU_CONFIG to affect the next boot via the XML
+ * VIR_DOMAIN_AFFECT_CONFIG to affect the next boot via the XML
  * description of the domain.  Both flags may be set.
  *
  * If @flags includes VIR_DOMAIN_VCPU_MAXIMUM, then
- * VIR_DOMAIN_VCPU_LIVE must be clear, and only the maximum virtual
+ * VIR_DOMAIN_AFFECT_LIVE must be clear, and only the maximum virtual
  * CPU limit is altered; generally, this value must be less than or
  * equal to virConnectGetMaxVcpus().  Otherwise, this call affects the
  * current virtual CPU limit, which must be less than or equal to the
@@ -6551,7 +6551,7 @@ virDomainSetVcpusFlags(virDomainPtr domain, unsigned int nvcpus,
 
     /* Perform some argument validation common to all implementations.  */
     if (nvcpus < 1 || (unsigned short) nvcpus != nvcpus ||
-        (flags & (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG)) == 0) {
+        (flags & (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG)) == 0) {
         virLibDomainError(VIR_ERR_INVALID_ARG, __FUNCTION__);
         goto error;
     }
@@ -6610,7 +6610,7 @@ virDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
     }
 
     /* Exactly one of these two flags should be set.  */
-    if (!(flags & VIR_DOMAIN_VCPU_LIVE) == !(flags & VIR_DOMAIN_VCPU_CONFIG)) {
+    if (!(flags & VIR_DOMAIN_AFFECT_LIVE) == !(flags & VIR_DOMAIN_AFFECT_CONFIG)) {
         virLibDomainError(VIR_ERR_INVALID_ARG, __FUNCTION__);
         goto error;
     }
@@ -6958,11 +6958,11 @@ error:
  * @flags: an OR'ed set of virDomainDeviceModifyFlags
  *
  * Attach a virtual device to a domain, using the flags parameter
- * to control how the device is attached.  VIR_DOMAIN_DEVICE_MODIFY_CURRENT
+ * to control how the device is attached.  VIR_DOMAIN_AFFECT_CURRENT
  * specifies that the device allocation is made based on current domain
- * state.  VIR_DOMAIN_DEVICE_MODIFY_LIVE specifies that the device shall be
+ * state.  VIR_DOMAIN_AFFECT_LIVE specifies that the device shall be
  * allocated to the active domain instance only and is not added to the
- * persisted domain configuration.  VIR_DOMAIN_DEVICE_MODIFY_CONFIG
+ * persisted domain configuration.  VIR_DOMAIN_AFFECT_CONFIG
  * specifies that the device shall be allocated to the persisted domain
  * configuration only.  Note that the target hypervisor must return an
  * error if unable to satisfy flags.  E.g. the hypervisor driver will
@@ -7075,11 +7075,11 @@ error:
  * @flags: an OR'ed set of virDomainDeviceModifyFlags
  *
  * Detach a virtual device from a domain, using the flags parameter
- * to control how the device is detached.  VIR_DOMAIN_DEVICE_MODIFY_CURRENT
+ * to control how the device is detached.  VIR_DOMAIN_AFFECT_CURRENT
  * specifies that the device allocation is removed based on current domain
- * state.  VIR_DOMAIN_DEVICE_MODIFY_LIVE specifies that the device shall be
+ * state.  VIR_DOMAIN_AFFECT_LIVE specifies that the device shall be
  * deallocated from the active domain instance only and is not from the
- * persisted domain configuration.  VIR_DOMAIN_DEVICE_MODIFY_CONFIG
+ * persisted domain configuration.  VIR_DOMAIN_AFFECT_CONFIG
  * specifies that the device shall be deallocated from the persisted domain
  * configuration only.  Note that the target hypervisor must return an
  * error if unable to satisfy flags.  E.g. the hypervisor driver will
@@ -7137,11 +7137,11 @@ error:
  * @flags: an OR'ed set of virDomainDeviceModifyFlags
  *
  * Change a virtual device on a domain, using the flags parameter
- * to control how the device is changed.  VIR_DOMAIN_DEVICE_MODIFY_CURRENT
+ * to control how the device is changed.  VIR_DOMAIN_AFFECT_CURRENT
  * specifies that the device change is made based on current domain
- * state.  VIR_DOMAIN_DEVICE_MODIFY_LIVE specifies that the device shall be
+ * state.  VIR_DOMAIN_AFFECT_LIVE specifies that the device shall be
  * changed on the active domain instance only and is not added to the
- * persisted domain configuration. VIR_DOMAIN_DEVICE_MODIFY_CONFIG
+ * persisted domain configuration. VIR_DOMAIN_AFFECT_CONFIG
  * specifies that the device shall be changed on the persisted domain
  * configuration only.  Note that the target hypervisor must return an
  * error if unable to satisfy flags.  E.g. the hypervisor driver will
diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c
index e24b5d8..645e426 100644
--- a/src/openvz/openvz_driver.c
+++ b/src/openvz/openvz_driver.c
@@ -1200,7 +1200,7 @@ static int
 openvzDomainGetVcpusFlags(virDomainPtr dom ATTRIBUTE_UNUSED,
                           unsigned int flags)
 {
-    if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) {
+    if (flags != (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) {
         openvzError(VIR_ERR_INVALID_ARG, _("unsupported flags (0x%x)"), flags);
         return -1;
     }
@@ -1210,7 +1210,7 @@ openvzDomainGetVcpusFlags(virDomainPtr dom ATTRIBUTE_UNUSED,
 
 static int openvzDomainGetMaxVcpus(virDomainPtr dom)
 {
-    return openvzDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE |
+    return openvzDomainGetVcpusFlags(dom, (VIR_DOMAIN_AFFECT_LIVE |
                                            VIR_DOMAIN_VCPU_MAXIMUM));
 }
 
@@ -1244,7 +1244,7 @@ static int openvzDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
     struct openvz_driver   *driver = dom->conn->privateData;
     int                     ret = -1;
 
-    if (flags != VIR_DOMAIN_VCPU_LIVE) {
+    if (flags != VIR_DOMAIN_AFFECT_LIVE) {
         openvzError(VIR_ERR_INVALID_ARG, _("unsupported flags (0x%x)"), flags);
         return -1;
     }
@@ -1277,7 +1277,7 @@ cleanup:
 static int
 openvzDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus)
 {
-    return openvzDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE);
+    return openvzDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_AFFECT_LIVE);
 }
 
 static virDrvOpenStatus openvzOpen(virConnectPtr conn,
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 80de79a..8083707 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -1595,8 +1595,8 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
     int ret = -1, r;
     bool isActive;
 
-    virCheckFlags(VIR_DOMAIN_MEM_LIVE |
-                  VIR_DOMAIN_MEM_CONFIG |
+    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
+                  VIR_DOMAIN_AFFECT_CONFIG |
                   VIR_DOMAIN_MEM_MAXIMUM, -1);
 
     qemuDriverLock(driver);
@@ -1615,26 +1615,26 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
 
     isActive = virDomainObjIsActive(vm);
 
-    if (flags == VIR_DOMAIN_MEM_CURRENT) {
+    if (flags == VIR_DOMAIN_AFFECT_CURRENT) {
         if (isActive)
-            flags = VIR_DOMAIN_MEM_LIVE;
+            flags = VIR_DOMAIN_AFFECT_LIVE;
         else
-            flags = VIR_DOMAIN_MEM_CONFIG;
+            flags = VIR_DOMAIN_AFFECT_CONFIG;
     }
     if (flags == VIR_DOMAIN_MEM_MAXIMUM) {
         if (isActive)
-            flags = VIR_DOMAIN_MEM_LIVE | VIR_DOMAIN_MEM_MAXIMUM;
+            flags = VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_MEM_MAXIMUM;
         else
-            flags = VIR_DOMAIN_MEM_CONFIG | VIR_DOMAIN_MEM_MAXIMUM;
+            flags = VIR_DOMAIN_AFFECT_CONFIG | VIR_DOMAIN_MEM_MAXIMUM;
     }
 
-    if (!isActive && (flags & VIR_DOMAIN_MEM_LIVE)) {
+    if (!isActive && (flags & VIR_DOMAIN_AFFECT_LIVE)) {
         qemuReportError(VIR_ERR_OPERATION_INVALID,
                         "%s", _("domain is not running"));
         goto endjob;
     }
 
-    if (flags & VIR_DOMAIN_MEM_CONFIG) {
+    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
         if (!vm->persistent) {
             qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
                             _("cannot change persistent config of a transient domain"));
@@ -1647,14 +1647,14 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
     if (flags & VIR_DOMAIN_MEM_MAXIMUM) {
         /* resize the maximum memory */
 
-        if (flags & VIR_DOMAIN_MEM_LIVE) {
+        if (flags & VIR_DOMAIN_AFFECT_LIVE) {
             qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
                             _("cannot resize the maximum memory on an "
                               "active domain"));
             goto endjob;
         }
 
-        if (flags & VIR_DOMAIN_MEM_CONFIG) {
+        if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
             /* Help clang 2.8 decipher the logic flow.  */
             sa_assert(persistentDef);
             persistentDef->mem.max_balloon = newmem;
@@ -1673,7 +1673,7 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
             goto endjob;
         }
 
-        if (flags & VIR_DOMAIN_MEM_LIVE) {
+        if (flags & VIR_DOMAIN_AFFECT_LIVE) {
             priv = vm->privateData;
             qemuDomainObjEnterMonitor(vm);
             r = qemuMonitorSetBalloon(priv->mon, newmem);
@@ -1691,7 +1691,7 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
             }
         }
 
-        if (flags & VIR_DOMAIN_MEM_CONFIG) {
+        if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
             sa_assert(persistentDef);
             persistentDef->mem.cur_balloon = newmem;
             ret = virDomainSaveConfig(driver->configDir, persistentDef);
@@ -1712,7 +1712,7 @@ cleanup:
 
 static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem)
 {
-    return qemudDomainSetMemoryFlags(dom, newmem, VIR_DOMAIN_MEM_LIVE);
+    return qemudDomainSetMemoryFlags(dom, newmem, VIR_DOMAIN_AFFECT_LIVE);
 }
 
 static int qemudDomainSetMaxMemory(virDomainPtr dom, unsigned long memory)
@@ -2760,15 +2760,15 @@ qemudDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
     int max;
     int ret = -1;
 
-    virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
-                  VIR_DOMAIN_VCPU_CONFIG |
+    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
+                  VIR_DOMAIN_AFFECT_CONFIG |
                   VIR_DOMAIN_VCPU_MAXIMUM, -1);
 
     /* At least one of LIVE or CONFIG must be set.  MAXIMUM cannot be
      * mixed with LIVE.  */
-    if ((flags & (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG)) == 0 ||
-        (flags & (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_LIVE)) ==
-         (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_LIVE)) {
+    if ((flags & (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG)) == 0 ||
+        (flags & (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_AFFECT_LIVE)) ==
+         (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_AFFECT_LIVE)) {
         qemuReportError(VIR_ERR_INVALID_ARG,
                         _("invalid flag combination: (0x%x)"), flags);
         return -1;
@@ -2794,13 +2794,13 @@ qemudDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
     if (qemuDomainObjBeginJob(vm) < 0)
         goto cleanup;
 
-    if (!virDomainObjIsActive(vm) && (flags & VIR_DOMAIN_VCPU_LIVE)) {
+    if (!virDomainObjIsActive(vm) && (flags & VIR_DOMAIN_AFFECT_LIVE)) {
         qemuReportError(VIR_ERR_OPERATION_INVALID,
                          "%s", _("domain is not running"));
         goto endjob;
     }
 
-    if (!vm->persistent && (flags & VIR_DOMAIN_VCPU_CONFIG)) {
+    if (!vm->persistent && (flags & VIR_DOMAIN_AFFECT_CONFIG)) {
         qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
                         _("cannot change persistent config of a transient domain"));
         goto endjob;
@@ -2834,23 +2834,23 @@ qemudDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
         goto endjob;
 
     switch (flags) {
-    case VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_CONFIG:
+    case VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_AFFECT_CONFIG:
         persistentDef->maxvcpus = nvcpus;
         if (nvcpus < persistentDef->vcpus)
             persistentDef->vcpus = nvcpus;
         ret = 0;
         break;
 
-    case VIR_DOMAIN_VCPU_CONFIG:
+    case VIR_DOMAIN_AFFECT_CONFIG:
         persistentDef->vcpus = nvcpus;
         ret = 0;
         break;
 
-    case VIR_DOMAIN_VCPU_LIVE:
+    case VIR_DOMAIN_AFFECT_LIVE:
         ret = qemudDomainHotplugVcpus(vm, nvcpus);
         break;
 
-    case VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG:
+    case VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG:
         ret = qemudDomainHotplugVcpus(vm, nvcpus);
         if (ret == 0) {
             persistentDef->vcpus = nvcpus;
@@ -2859,7 +2859,7 @@ qemudDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
     }
 
     /* Save the persistent config to disk */
-    if (flags & VIR_DOMAIN_VCPU_CONFIG)
+    if (flags & VIR_DOMAIN_AFFECT_CONFIG)
         ret = virDomainSaveConfig(driver->configDir, persistentDef);
 
 endjob:
@@ -2875,7 +2875,7 @@ cleanup:
 static int
 qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus)
 {
-    return qemudDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE);
+    return qemudDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_AFFECT_LIVE);
 }
 
 
@@ -3049,12 +3049,12 @@ qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
     virDomainDefPtr def;
     int ret = -1;
 
-    virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
-                  VIR_DOMAIN_VCPU_CONFIG |
+    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
+                  VIR_DOMAIN_AFFECT_CONFIG |
                   VIR_DOMAIN_VCPU_MAXIMUM, -1);
 
     /* Exactly one of LIVE or CONFIG must be set.  */
-    if (!(flags & VIR_DOMAIN_VCPU_LIVE) == !(flags & VIR_DOMAIN_VCPU_CONFIG)) {
+    if (!(flags & VIR_DOMAIN_AFFECT_LIVE) == !(flags & VIR_DOMAIN_AFFECT_CONFIG)) {
         qemuReportError(VIR_ERR_INVALID_ARG,
                         _("invalid flag combination: (0x%x)"), flags);
         return -1;
@@ -3072,7 +3072,7 @@ qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
         goto cleanup;
     }
 
-    if (flags & VIR_DOMAIN_VCPU_LIVE) {
+    if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         if (!virDomainObjIsActive(vm)) {
             qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
                             _("domain not active"));
@@ -3094,7 +3094,7 @@ cleanup:
 static int
 qemudDomainGetMaxVcpus(virDomainPtr dom)
 {
-    return qemudDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE |
+    return qemudDomainGetVcpusFlags(dom, (VIR_DOMAIN_AFFECT_LIVE |
                                           VIR_DOMAIN_VCPU_MAXIMUM));
 }
 
@@ -4458,8 +4458,8 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
     bool force = (flags & VIR_DOMAIN_DEVICE_MODIFY_FORCE) != 0;
     int ret = -1;
 
-    virCheckFlags(VIR_DOMAIN_DEVICE_MODIFY_LIVE |
-                  VIR_DOMAIN_DEVICE_MODIFY_CONFIG |
+    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
+                  VIR_DOMAIN_AFFECT_CONFIG |
                   (action == QEMU_DEVICE_UPDATE ?
                    VIR_DOMAIN_DEVICE_MODIFY_FORCE : 0), -1);
 
@@ -4477,13 +4477,13 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
         goto cleanup;
 
     if (virDomainObjIsActive(vm)) {
-        if (flags == VIR_DOMAIN_DEVICE_MODIFY_CURRENT)
-            flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+        if (flags == VIR_DOMAIN_AFFECT_CURRENT)
+            flags |= VIR_DOMAIN_AFFECT_LIVE;
     } else {
-        if (flags == VIR_DOMAIN_DEVICE_MODIFY_CURRENT)
-            flags |= VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+        if (flags == VIR_DOMAIN_AFFECT_CURRENT)
+            flags |= VIR_DOMAIN_AFFECT_CONFIG;
         /* check consistency between flags and the vm state */
-        if (flags & VIR_DOMAIN_DEVICE_MODIFY_LIVE) {
+        if (flags & VIR_DOMAIN_AFFECT_LIVE) {
             qemuReportError(VIR_ERR_OPERATION_INVALID,
                             "%s",
                             _("cannot do live update a device on "
@@ -4492,13 +4492,13 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
         }
     }
 
-    if ((flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) && !vm->persistent) {
+    if ((flags & VIR_DOMAIN_AFFECT_CONFIG) && !vm->persistent) {
          qemuReportError(VIR_ERR_OPERATION_INVALID,
                          "%s", _("cannot modify device on transient domain"));
          goto endjob;
     }
 
-    if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
+    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
         dev = virDomainDeviceDefParse(driver->caps, vm->def, xml,
                                       VIR_DOMAIN_XML_INACTIVE);
         if (dev == NULL)
@@ -4526,7 +4526,7 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
     } else
         ret = 0;
 
-    if (!ret && (flags & VIR_DOMAIN_DEVICE_MODIFY_LIVE)) {
+    if (!ret && (flags & VIR_DOMAIN_AFFECT_LIVE)) {
         /* If dev exists it was created to modify the domain config. Free it. */
         virDomainDeviceDefFree(dev);
         dev = virDomainDeviceDefParse(driver->caps, vm->def, xml,
@@ -4558,7 +4558,7 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
             ret = -1;
     }
     /* Finally, if no error until here, we can save config. */
-    if (!ret && (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG)) {
+    if (!ret && (flags & VIR_DOMAIN_AFFECT_CONFIG)) {
         ret = virDomainSaveConfig(driver->configDir, vmdef);
         if (!ret) {
             virDomainObjAssignDef(vm, vmdef, false);
@@ -4588,7 +4588,7 @@ static int qemuDomainAttachDeviceFlags(virDomainPtr dom, const char *xml,
 static int qemuDomainAttachDevice(virDomainPtr dom, const char *xml)
 {
     return qemuDomainAttachDeviceFlags(dom, xml,
-                                       VIR_DOMAIN_DEVICE_MODIFY_LIVE);
+                                       VIR_DOMAIN_AFFECT_LIVE);
 }
 
 
@@ -4608,7 +4608,7 @@ static int qemuDomainDetachDeviceFlags(virDomainPtr dom, const char *xml,
 static int qemuDomainDetachDevice(virDomainPtr dom, const char *xml)
 {
     return qemuDomainDetachDeviceFlags(dom, xml,
-                                       VIR_DOMAIN_DEVICE_MODIFY_LIVE);
+                                       VIR_DOMAIN_AFFECT_LIVE);
 }
 
 static int qemudDomainGetAutostart(virDomainPtr dom,
diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index 2da24f1..efb75c7 100644
--- a/src/test/test_driver.c
+++ b/src/test/test_driver.c
@@ -2066,12 +2066,12 @@ testDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
     virDomainDefPtr def;
     int ret = -1;
 
-    virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
-                  VIR_DOMAIN_VCPU_CONFIG |
+    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
+                  VIR_DOMAIN_AFFECT_CONFIG |
                   VIR_DOMAIN_VCPU_MAXIMUM, -1);
 
     /* Exactly one of LIVE or CONFIG must be set.  */
-    if (!(flags & VIR_DOMAIN_VCPU_LIVE) == !(flags & VIR_DOMAIN_VCPU_CONFIG)) {
+    if (!(flags & VIR_DOMAIN_AFFECT_LIVE) == !(flags & VIR_DOMAIN_AFFECT_CONFIG)) {
         testError(VIR_ERR_INVALID_ARG,
                   _("invalid flag combination: (0x%x)"), flags);
         return -1;
@@ -2089,7 +2089,7 @@ testDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
         goto cleanup;
     }
 
-    if (flags & VIR_DOMAIN_VCPU_LIVE) {
+    if (flags & VIR_DOMAIN_AFFECT_LIVE) {
         if (!virDomainObjIsActive(vm)) {
             testError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("domain not active"));
@@ -2111,7 +2111,7 @@ cleanup:
 static int
 testDomainGetMaxVcpus(virDomainPtr domain)
 {
-    return testDomainGetVcpusFlags(domain, (VIR_DOMAIN_VCPU_LIVE |
+    return testDomainGetVcpusFlags(domain, (VIR_DOMAIN_AFFECT_LIVE |
                                             VIR_DOMAIN_VCPU_MAXIMUM));
 }
 
@@ -2124,15 +2124,15 @@ testDomainSetVcpusFlags(virDomainPtr domain, unsigned int nrCpus,
     virDomainDefPtr persistentDef;
     int ret = -1, maxvcpus;
 
-    virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
-                  VIR_DOMAIN_VCPU_CONFIG |
+    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
+                  VIR_DOMAIN_AFFECT_CONFIG |
                   VIR_DOMAIN_VCPU_MAXIMUM, -1);
 
     /* At least one of LIVE or CONFIG must be set.  MAXIMUM cannot be
      * mixed with LIVE.  */
-    if ((flags & (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG)) == 0 ||
-        (flags & (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_LIVE)) ==
-         (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_LIVE)) {
+    if ((flags & (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG)) == 0 ||
+        (flags & (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_AFFECT_LIVE)) ==
+         (VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_AFFECT_LIVE)) {
         testError(VIR_ERR_INVALID_ARG,
                   _("invalid flag combination: (0x%x)"), flags);
         return -1;
@@ -2152,7 +2152,7 @@ testDomainSetVcpusFlags(virDomainPtr domain, unsigned int nrCpus,
         goto cleanup;
     }
 
-    if (!virDomainObjIsActive(privdom) && (flags & VIR_DOMAIN_VCPU_LIVE)) {
+    if (!virDomainObjIsActive(privdom) && (flags & VIR_DOMAIN_AFFECT_LIVE)) {
         testError(VIR_ERR_OPERATION_INVALID,
                   "%s", _("cannot hotplug vcpus for an inactive domain"));
         goto cleanup;
@@ -2176,23 +2176,23 @@ testDomainSetVcpusFlags(virDomainPtr domain, unsigned int nrCpus,
         goto cleanup;
 
     switch (flags) {
-    case VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_CONFIG:
+    case VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_AFFECT_CONFIG:
         persistentDef->maxvcpus = nrCpus;
         if (nrCpus < persistentDef->vcpus)
             persistentDef->vcpus = nrCpus;
         ret = 0;
         break;
 
-    case VIR_DOMAIN_VCPU_CONFIG:
+    case VIR_DOMAIN_AFFECT_CONFIG:
         persistentDef->vcpus = nrCpus;
         ret = 0;
         break;
 
-    case VIR_DOMAIN_VCPU_LIVE:
+    case VIR_DOMAIN_AFFECT_LIVE:
         ret = testDomainUpdateVCPUs(domain->conn, privdom, nrCpus, 0);
         break;
 
-    case VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG:
+    case VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG:
         ret = testDomainUpdateVCPUs(domain->conn, privdom, nrCpus, 0);
         if (ret == 0) {
             persistentDef->vcpus = nrCpus;
@@ -2209,7 +2209,7 @@ cleanup:
 static int
 testSetVcpus(virDomainPtr domain, unsigned int nrCpus)
 {
-    return testDomainSetVcpusFlags(domain, nrCpus, VIR_DOMAIN_VCPU_LIVE);
+    return testDomainSetVcpusFlags(domain, nrCpus, VIR_DOMAIN_AFFECT_LIVE);
 }
 
 static int testDomainGetVcpus(virDomainPtr domain,
diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c
index 536cd8c..4427e95 100644
--- a/src/uml/uml_driver.c
+++ b/src/uml/uml_driver.c
@@ -1831,7 +1831,7 @@ cleanup:
 static int umlDomainAttachDeviceFlags(virDomainPtr dom,
                                       const char *xml,
                                       unsigned int flags) {
-    if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
+    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
         umlReportError(VIR_ERR_OPERATION_INVALID,
                        "%s", _("cannot modify the persistent configuration of a domain"));
         return -1;
@@ -1939,7 +1939,7 @@ cleanup:
 static int umlDomainDetachDeviceFlags(virDomainPtr dom,
                                       const char *xml,
                                       unsigned int flags) {
-    if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
+    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
         umlReportError(VIR_ERR_OPERATION_INVALID,
                        "%s", _("cannot modify the persistent configuration of a domain"));
         return -1;
diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c
index 2986f5a..f2233a5 100644
--- a/src/vbox/vbox_tmpl.c
+++ b/src/vbox/vbox_tmpl.c
@@ -2044,7 +2044,7 @@ vboxDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
     PRUint32  CPUCount   = nvcpus;
     nsresult rc;
 
-    if (flags != VIR_DOMAIN_VCPU_LIVE) {
+    if (flags != VIR_DOMAIN_AFFECT_LIVE) {
         vboxError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags);
         return -1;
     }
@@ -2092,7 +2092,7 @@ vboxDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
 static int
 vboxDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus)
 {
-    return vboxDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE);
+    return vboxDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_AFFECT_LIVE);
 }
 
 static int
@@ -2102,7 +2102,7 @@ vboxDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
     ISystemProperties *systemProperties = NULL;
     PRUint32 maxCPUCount = 0;
 
-    if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) {
+    if (flags != (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) {
         vboxError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags);
         return -1;
     }
@@ -2127,7 +2127,7 @@ vboxDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
 static int
 vboxDomainGetMaxVcpus(virDomainPtr dom)
 {
-    return vboxDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE |
+    return vboxDomainGetVcpusFlags(dom, (VIR_DOMAIN_AFFECT_LIVE |
                                          VIR_DOMAIN_VCPU_MAXIMUM));
 }
 
@@ -5292,7 +5292,7 @@ static int vboxDomainAttachDevice(virDomainPtr dom, const char *xml) {
 
 static int vboxDomainAttachDeviceFlags(virDomainPtr dom, const char *xml,
                                        unsigned int flags) {
-    if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
+    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
         vboxError(VIR_ERR_OPERATION_INVALID, "%s",
                   _("cannot modify the persistent configuration of a domain"));
         return -1;
@@ -5303,11 +5303,11 @@ static int vboxDomainAttachDeviceFlags(virDomainPtr dom, const char *xml,
 
 static int vboxDomainUpdateDeviceFlags(virDomainPtr dom, const char *xml,
                                        unsigned int flags) {
-    virCheckFlags(VIR_DOMAIN_DEVICE_MODIFY_CURRENT |
-                  VIR_DOMAIN_DEVICE_MODIFY_LIVE |
-                  VIR_DOMAIN_DEVICE_MODIFY_CONFIG, -1);
+    virCheckFlags(VIR_DOMAIN_AFFECT_CURRENT |
+                  VIR_DOMAIN_AFFECT_LIVE |
+                  VIR_DOMAIN_AFFECT_CONFIG, -1);
 
-    if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
+    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
         vboxError(VIR_ERR_OPERATION_INVALID, "%s",
                   _("cannot modify the persistent configuration of a domain"));
         return -1;
@@ -5442,7 +5442,7 @@ cleanup:
 
 static int vboxDomainDetachDeviceFlags(virDomainPtr dom, const char *xml,
                                        unsigned int flags) {
-    if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
+    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
         vboxError(VIR_ERR_OPERATION_INVALID, "%s",
                   _("cannot modify the persistent configuration of a domain"));
         return -1;
diff --git a/tools/virsh.c b/tools/virsh.c
index d98be1c..5663f3f 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -2718,7 +2718,7 @@ cmdVcpucount(vshControl *ctl, const vshCmd *cmd)
      * up.  */
     if (all || (maximum && config)) {
         count = virDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_MAXIMUM |
-                                             VIR_DOMAIN_VCPU_CONFIG));
+                                             VIR_DOMAIN_AFFECT_CONFIG));
         if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT
                           || last_error->code == VIR_ERR_INVALID_ARG)) {
             char *tmp;
@@ -2748,7 +2748,7 @@ cmdVcpucount(vshControl *ctl, const vshCmd *cmd)
 
     if (all || (maximum && live)) {
         count = virDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_MAXIMUM |
-                                             VIR_DOMAIN_VCPU_LIVE));
+                                             VIR_DOMAIN_AFFECT_LIVE));
         if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT
                           || last_error->code == VIR_ERR_INVALID_ARG)) {
             count = virDomainGetMaxVcpus(dom);
@@ -2768,7 +2768,7 @@ cmdVcpucount(vshControl *ctl, const vshCmd *cmd)
     }
 
     if (all || (current && config)) {
-        count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_VCPU_CONFIG);
+        count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_AFFECT_CONFIG);
         if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT
                           || last_error->code == VIR_ERR_INVALID_ARG)) {
             char *tmp, *end;
@@ -2805,7 +2805,7 @@ cmdVcpucount(vshControl *ctl, const vshCmd *cmd)
     }
 
     if (all || (current && live)) {
-        count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_VCPU_LIVE);
+        count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_AFFECT_LIVE);
         if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT
                           || last_error->code == VIR_ERR_INVALID_ARG)) {
             virDomainInfo info;
@@ -3078,8 +3078,8 @@ cmdSetvcpus(vshControl *ctl, const vshCmd *cmd)
     int config = vshCommandOptBool(cmd, "config");
     int live = vshCommandOptBool(cmd, "live");
     int flags = ((maximum ? VIR_DOMAIN_VCPU_MAXIMUM : 0) |
-                 (config ? VIR_DOMAIN_VCPU_CONFIG : 0) |
-                 (live ? VIR_DOMAIN_VCPU_LIVE : 0));
+                 (config ? VIR_DOMAIN_AFFECT_CONFIG : 0) |
+                 (live ? VIR_DOMAIN_AFFECT_LIVE : 0));
 
     if (!vshConnectionUsability(ctl, ctl->conn))
         return false;
@@ -3195,12 +3195,12 @@ cmdSetmem(vshControl *ctl, const vshCmd *cmd)
             vshError(ctl, "%s", _("--current must be specified exclusively"));
             return false;
         }
-        flags = VIR_DOMAIN_MEM_CURRENT;
+        flags = VIR_DOMAIN_AFFECT_CURRENT;
     } else {
         if (config)
-            flags |= VIR_DOMAIN_MEM_CONFIG;
+            flags |= VIR_DOMAIN_AFFECT_CONFIG;
         if (live)
-            flags |= VIR_DOMAIN_MEM_LIVE;
+            flags |= VIR_DOMAIN_AFFECT_LIVE;
         /* neither option is specified */
         if (!live && !config)
             flags = -1;
@@ -3286,9 +3286,9 @@ cmdSetmaxmem(vshControl *ctl, const vshCmd *cmd)
         }
     } else {
         if (config)
-            flags |= VIR_DOMAIN_MEM_CONFIG;
+            flags |= VIR_DOMAIN_AFFECT_CONFIG;
         if (live)
-            flags |= VIR_DOMAIN_MEM_LIVE;
+            flags |= VIR_DOMAIN_AFFECT_LIVE;
         /* neither option is specified */
         if (!live && !config)
             flags = -1;
@@ -9281,9 +9281,9 @@ cmdAttachDevice(vshControl *ctl, const vshCmd *cmd)
     }
 
     if (vshCommandOptBool(cmd, "persistent")) {
-        flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+        flags = VIR_DOMAIN_AFFECT_CONFIG;
         if (virDomainIsActive(dom) == 1)
-           flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+           flags |= VIR_DOMAIN_AFFECT_LIVE;
         ret = virDomainAttachDeviceFlags(dom, buffer, flags);
     } else {
         ret = virDomainAttachDevice(dom, buffer);
@@ -9346,9 +9346,9 @@ cmdDetachDevice(vshControl *ctl, const vshCmd *cmd)
     }
 
     if (vshCommandOptBool(cmd, "persistent")) {
-        flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+        flags = VIR_DOMAIN_AFFECT_CONFIG;
         if (virDomainIsActive(dom) == 1)
-           flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+           flags |= VIR_DOMAIN_AFFECT_LIVE;
         ret = virDomainDetachDeviceFlags(dom, buffer, flags);
     } else {
         ret = virDomainDetachDevice(dom, buffer);
@@ -9412,11 +9412,11 @@ cmdUpdateDevice(vshControl *ctl, const vshCmd *cmd)
     }
 
     if (vshCommandOptBool(cmd, "persistent")) {
-        flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+        flags = VIR_DOMAIN_AFFECT_CONFIG;
         if (virDomainIsActive(dom) == 1)
-           flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+           flags |= VIR_DOMAIN_AFFECT_LIVE;
     } else {
-        flags = VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+        flags = VIR_DOMAIN_AFFECT_LIVE;
     }
 
     if (vshCommandOptBool(cmd, "force"))
@@ -9528,9 +9528,9 @@ cmdAttachInterface(vshControl *ctl, const vshCmd *cmd)
     xml = virBufferContentAndReset(&buf);
 
     if (vshCommandOptBool(cmd, "persistent")) {
-        flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+        flags = VIR_DOMAIN_AFFECT_CONFIG;
         if (virDomainIsActive(dom) == 1)
-            flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+            flags |= VIR_DOMAIN_AFFECT_LIVE;
         ret = virDomainAttachDeviceFlags(dom, xml, flags);
     } else {
         ret = virDomainAttachDevice(dom, xml);
@@ -9667,9 +9667,9 @@ cmdDetachInterface(vshControl *ctl, const vshCmd *cmd)
     }
 
     if (vshCommandOptBool(cmd, "persistent")) {
-        flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+        flags = VIR_DOMAIN_AFFECT_CONFIG;
         if (virDomainIsActive(dom) == 1)
-            flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+            flags |= VIR_DOMAIN_AFFECT_LIVE;
         ret = virDomainDetachDeviceFlags(dom,
                                          (char *)xmlBufferContent(xml_buf),
                                          flags);
@@ -9805,9 +9805,9 @@ cmdAttachDisk(vshControl *ctl, const vshCmd *cmd)
     xml = virBufferContentAndReset(&buf);
 
     if (vshCommandOptBool(cmd, "persistent")) {
-        flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+        flags = VIR_DOMAIN_AFFECT_CONFIG;
         if (virDomainIsActive(dom) == 1)
-            flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+            flags |= VIR_DOMAIN_AFFECT_LIVE;
         ret = virDomainAttachDeviceFlags(dom, xml, flags);
     } else {
         ret = virDomainAttachDevice(dom, xml);
@@ -9927,9 +9927,9 @@ cmdDetachDisk(vshControl *ctl, const vshCmd *cmd)
     }
 
     if (vshCommandOptBool(cmd, "persistent")) {
-        flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+        flags = VIR_DOMAIN_AFFECT_CONFIG;
         if (virDomainIsActive(dom) == 1)
-            flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+            flags |= VIR_DOMAIN_AFFECT_LIVE;
         ret = virDomainDetachDeviceFlags(dom,
                                          (char *)xmlBufferContent(xml_buf),
                                          flags);
-- 
1.7.3.1


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