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