This patch unify the PARAM_CURRENT/PARAM_LIVE/PARAM_CONFIG flags as
Daniel Veillard suggested.
---
include/libvirt/libvirt.h.in | 58 ++++---------
src/esx/esx_driver.c | 10 +-
src/libvirt.c | 4 +-
src/openvz/openvz_driver.c | 10 +-
src/qemu/qemu_driver.c | 194 +++++++++++++++++++++---------------------
src/test/test_driver.c | 42 +++++-----
src/uml/uml_driver.c | 4 +-
src/vbox/vbox_tmpl.c | 22 +++---
tools/virsh.c | 74 ++++++++--------
9 files changed, 196 insertions(+), 222 deletions(-)
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index 8058229..8ef07b0 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -142,6 +142,22 @@ typedef enum {
} virDomainCrashedReason;
/**
+ * virDomainParamFlags:
+ *
+ * common flags for commands that support --current, --live, --config
+ * and --force parameters
+ */
+
+typedef enum {
+ VIR_DOMAIN_PARAM_CURRENT = 0, /* affect current domain state */
+ VIR_DOMAIN_PARAM_LIVE = (1 << 0), /* affect active domain */
+ VIR_DOMAIN_PARAM_CONFIG = (1 << 1), /* affect next boot */
+ VIR_DOMAIN_PARAM_FORCE = (1 << 2), /* Forcibly modify device
+ (ex. force eject a cdrom) */
+ VIR_DOMAIN_PARAM_MAXIMUM = (1 << 3), /* affect Max rather than current */
+} virDomainParamFlags;
+
+/**
* virDomainInfoPtr:
*
* a virDomainInfo is a structure filled by virDomainGetInfo() and extracting
@@ -338,12 +354,6 @@ typedef virTypedParameter *virTypedParameterPtr;
/* Management of scheduler parameters */
-typedef enum {
- VIR_DOMAIN_SCHEDPARAM_CURRENT = 0, /* affect current domain state */
- VIR_DOMAIN_SCHEDPARAM_LIVE = (1 << 0), /* Affect active domain */
- VIR_DOMAIN_SCHEDPARAM_CONFIG = (1 << 1), /* Affect next boot */
-} virDomainSchedParameterFlags;
-
/*
* Fetch scheduler parameters, caller allocates 'params' field of size 'nparams'
*/
@@ -799,13 +809,6 @@ int virDomainGetBlkioParameters(virDomainPtr domain,
/* Manage memory parameters. */
-/* flags for setting memory parameters */
-typedef enum {
- VIR_DOMAIN_MEMORY_PARAM_CURRENT = 0, /* affect current domain state */
- VIR_DOMAIN_MEMORY_PARAM_LIVE = (1 << 0), /* affect active domain */
- VIR_DOMAIN_MEMORY_PARAM_CONFIG = (1 << 1) /* affect next boot */
-} virMemoryParamFlags;
-
/**
* VIR_DOMAIN_MEMORY_PARAM_UNLIMITED:
*
@@ -859,15 +862,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
*/
@@ -1023,16 +1017,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,
@@ -1131,16 +1115,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);
diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c
index 500dc52..ffce508 100644
--- a/src/esx/esx_driver.c
+++ b/src/esx/esx_driver.c
@@ -2540,7 +2540,7 @@ esxDomainSetVcpusFlags(virDomainPtr domain, unsigned int nvcpus,
esxVI_TaskInfoState taskInfoState;
char *taskInfoErrorMessage = NULL;
- if (flags != VIR_DOMAIN_VCPU_LIVE) {
+ if (flags != VIR_DOMAIN_PARAM_LIVE) {
ESX_ERROR(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags);
return -1;
}
@@ -2611,7 +2611,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_PARAM_LIVE);
}
@@ -2624,7 +2624,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_PARAM_LIVE | VIR_DOMAIN_PARAM_MAXIMUM)) {
ESX_ERROR(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags);
return -1;
}
@@ -2679,8 +2679,8 @@ esxDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
static int
esxDomainGetMaxVcpus(virDomainPtr domain)
{
- return esxDomainGetVcpusFlags(domain, (VIR_DOMAIN_VCPU_LIVE |
- VIR_DOMAIN_VCPU_MAXIMUM));
+ return esxDomainGetVcpusFlags(domain, (VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_MAXIMUM));
}
diff --git a/src/libvirt.c b/src/libvirt.c
index ee5c7cd..611e299 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -6616,7 +6616,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_PARAM_LIVE | VIR_DOMAIN_PARAM_CONFIG)) == 0) {
virLibDomainError(VIR_ERR_INVALID_ARG, __FUNCTION__);
goto error;
}
@@ -6675,7 +6675,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_PARAM_LIVE) == !(flags & VIR_DOMAIN_PARAM_CONFIG)) {
virLibDomainError(VIR_ERR_INVALID_ARG, __FUNCTION__);
goto error;
}
diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c
index e24b5d8..0727bfa 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_PARAM_LIVE | VIR_DOMAIN_PARAM_MAXIMUM)) {
openvzError(VIR_ERR_INVALID_ARG, _("unsupported flags (0x%x)"), flags);
return -1;
}
@@ -1210,8 +1210,8 @@ openvzDomainGetVcpusFlags(virDomainPtr dom ATTRIBUTE_UNUSED,
static int openvzDomainGetMaxVcpus(virDomainPtr dom)
{
- return openvzDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE |
- VIR_DOMAIN_VCPU_MAXIMUM));
+ return openvzDomainGetVcpusFlags(dom, (VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_MAXIMUM));
}
static int openvzDomainSetVcpusInternal(virDomainObjPtr vm,
@@ -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_PARAM_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_PARAM_LIVE);
}
static virDrvOpenStatus openvzOpen(virConnectPtr conn,
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 8509391..43bb0fc 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -1584,9 +1584,9 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
int ret = -1, r;
bool isActive;
- virCheckFlags(VIR_DOMAIN_MEM_LIVE |
- VIR_DOMAIN_MEM_CONFIG |
- VIR_DOMAIN_MEM_MAXIMUM, -1);
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG |
+ VIR_DOMAIN_PARAM_MAXIMUM, -1);
qemuDriverLock(driver);
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
@@ -1604,26 +1604,26 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
isActive = virDomainObjIsActive(vm);
- if (flags == VIR_DOMAIN_MEM_CURRENT) {
+ if (flags == VIR_DOMAIN_PARAM_CURRENT) {
if (isActive)
- flags = VIR_DOMAIN_MEM_LIVE;
+ flags = VIR_DOMAIN_PARAM_LIVE;
else
- flags = VIR_DOMAIN_MEM_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
}
- if (flags == VIR_DOMAIN_MEM_MAXIMUM) {
+ if (flags == VIR_DOMAIN_PARAM_MAXIMUM) {
if (isActive)
- flags = VIR_DOMAIN_MEM_LIVE | VIR_DOMAIN_MEM_MAXIMUM;
+ flags = VIR_DOMAIN_PARAM_LIVE | VIR_DOMAIN_PARAM_MAXIMUM;
else
- flags = VIR_DOMAIN_MEM_CONFIG | VIR_DOMAIN_MEM_MAXIMUM;
+ flags = VIR_DOMAIN_PARAM_CONFIG | VIR_DOMAIN_PARAM_MAXIMUM;
}
- if (!isActive && (flags & VIR_DOMAIN_MEM_LIVE)) {
+ if (!isActive && (flags & VIR_DOMAIN_PARAM_LIVE)) {
qemuReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("domain is not running"));
goto endjob;
}
- if (flags & VIR_DOMAIN_MEM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
if (!vm->persistent) {
qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("cannot change persistent config of a transient domain"));
@@ -1633,17 +1633,17 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
goto endjob;
}
- if (flags & VIR_DOMAIN_MEM_MAXIMUM) {
+ if (flags & VIR_DOMAIN_PARAM_MAXIMUM) {
/* resize the maximum memory */
- if (flags & VIR_DOMAIN_MEM_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_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_PARAM_CONFIG) {
/* Help clang 2.8 decipher the logic flow. */
sa_assert(persistentDef);
persistentDef->mem.max_balloon = newmem;
@@ -1662,7 +1662,7 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
goto endjob;
}
- if (flags & VIR_DOMAIN_MEM_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
priv = vm->privateData;
qemuDomainObjEnterMonitor(vm);
r = qemuMonitorSetBalloon(priv->mon, newmem);
@@ -1680,7 +1680,7 @@ static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
}
}
- if (flags & VIR_DOMAIN_MEM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
sa_assert(persistentDef);
persistentDef->mem.cur_balloon = newmem;
ret = virDomainSaveConfig(driver->configDir, persistentDef);
@@ -1701,12 +1701,12 @@ cleanup:
static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem)
{
- return qemudDomainSetMemoryFlags(dom, newmem, VIR_DOMAIN_MEM_LIVE);
+ return qemudDomainSetMemoryFlags(dom, newmem, VIR_DOMAIN_PARAM_LIVE);
}
static int qemudDomainSetMaxMemory(virDomainPtr dom, unsigned long memory)
{
- return qemudDomainSetMemoryFlags(dom, memory, VIR_DOMAIN_MEM_MAXIMUM);
+ return qemudDomainSetMemoryFlags(dom, memory, VIR_DOMAIN_PARAM_MAXIMUM);
}
static int qemuDomainInjectNMI(virDomainPtr domain, unsigned int flags)
@@ -2749,15 +2749,15 @@ qemudDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
int max;
int ret = -1;
- virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
- VIR_DOMAIN_VCPU_CONFIG |
- VIR_DOMAIN_VCPU_MAXIMUM, -1);
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG |
+ VIR_DOMAIN_PARAM_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_PARAM_LIVE | VIR_DOMAIN_PARAM_CONFIG)) == 0 ||
+ (flags & (VIR_DOMAIN_PARAM_MAXIMUM | VIR_DOMAIN_PARAM_LIVE)) ==
+ (VIR_DOMAIN_PARAM_MAXIMUM | VIR_DOMAIN_PARAM_LIVE)) {
qemuReportError(VIR_ERR_INVALID_ARG,
_("invalid flag combination: (0x%x)"), flags);
return -1;
@@ -2783,13 +2783,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_PARAM_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_PARAM_CONFIG)) {
qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("cannot change persistent config of a transient domain"));
goto endjob;
@@ -2808,7 +2808,7 @@ qemudDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
goto endjob;
}
- if (!(flags & VIR_DOMAIN_VCPU_MAXIMUM) && vm->def->maxvcpus < max) {
+ if (!(flags & VIR_DOMAIN_PARAM_MAXIMUM) && vm->def->maxvcpus < max) {
max = vm->def->maxvcpus;
}
@@ -2823,23 +2823,23 @@ qemudDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
goto endjob;
switch (flags) {
- case VIR_DOMAIN_VCPU_MAXIMUM | VIR_DOMAIN_VCPU_CONFIG:
+ case VIR_DOMAIN_PARAM_MAXIMUM | VIR_DOMAIN_PARAM_CONFIG:
persistentDef->maxvcpus = nvcpus;
if (nvcpus < persistentDef->vcpus)
persistentDef->vcpus = nvcpus;
ret = 0;
break;
- case VIR_DOMAIN_VCPU_CONFIG:
+ case VIR_DOMAIN_PARAM_CONFIG:
persistentDef->vcpus = nvcpus;
ret = 0;
break;
- case VIR_DOMAIN_VCPU_LIVE:
+ case VIR_DOMAIN_PARAM_LIVE:
ret = qemudDomainHotplugVcpus(vm, nvcpus);
break;
- case VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG:
+ case VIR_DOMAIN_PARAM_LIVE | VIR_DOMAIN_PARAM_CONFIG:
ret = qemudDomainHotplugVcpus(vm, nvcpus);
if (ret == 0) {
persistentDef->vcpus = nvcpus;
@@ -2848,7 +2848,7 @@ qemudDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
}
/* Save the persistent config to disk */
- if (flags & VIR_DOMAIN_VCPU_CONFIG)
+ if (flags & VIR_DOMAIN_PARAM_CONFIG)
ret = virDomainSaveConfig(driver->configDir, persistentDef);
endjob:
@@ -2864,7 +2864,7 @@ cleanup:
static int
qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus)
{
- return qemudDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE);
+ return qemudDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_PARAM_LIVE);
}
@@ -3038,12 +3038,12 @@ qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
virDomainDefPtr def;
int ret = -1;
- virCheckFlags(VIR_DOMAIN_VCPU_LIVE |
- VIR_DOMAIN_VCPU_CONFIG |
- VIR_DOMAIN_VCPU_MAXIMUM, -1);
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG |
+ VIR_DOMAIN_PARAM_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_PARAM_LIVE) == !(flags & VIR_DOMAIN_PARAM_CONFIG)) {
qemuReportError(VIR_ERR_INVALID_ARG,
_("invalid flag combination: (0x%x)"), flags);
return -1;
@@ -3061,7 +3061,7 @@ qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
goto cleanup;
}
- if (flags & VIR_DOMAIN_VCPU_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
if (!virDomainObjIsActive(vm)) {
qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("domain not active"));
@@ -3072,7 +3072,7 @@ qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
def = vm->newDef ? vm->newDef : vm->def;
}
- ret = (flags & VIR_DOMAIN_VCPU_MAXIMUM) ? def->maxvcpus : def->vcpus;
+ ret = (flags & VIR_DOMAIN_PARAM_MAXIMUM) ? def->maxvcpus : def->vcpus;
cleanup:
if (vm)
@@ -3083,8 +3083,8 @@ cleanup:
static int
qemudDomainGetMaxVcpus(virDomainPtr dom)
{
- return qemudDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE |
- VIR_DOMAIN_VCPU_MAXIMUM));
+ return qemudDomainGetVcpusFlags(dom, (VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_MAXIMUM));
}
static int qemudDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr seclabel)
@@ -4406,13 +4406,13 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
virDomainObjPtr vm = NULL;
virDomainDefPtr vmdef = NULL;
virDomainDeviceDefPtr dev = NULL;
- bool force = (flags & VIR_DOMAIN_DEVICE_MODIFY_FORCE) != 0;
+ bool force = (flags & VIR_DOMAIN_PARAM_FORCE) != 0;
int ret = -1;
- virCheckFlags(VIR_DOMAIN_DEVICE_MODIFY_LIVE |
- VIR_DOMAIN_DEVICE_MODIFY_CONFIG |
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG |
(action == QEMU_DEVICE_UPDATE ?
- VIR_DOMAIN_DEVICE_MODIFY_FORCE : 0), -1);
+ VIR_DOMAIN_PARAM_FORCE : 0), -1);
qemuDriverLock(driver);
vm = virDomainFindByUUID(&driver->domains, dom->uuid);
@@ -4428,13 +4428,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_PARAM_CURRENT)
+ flags |= VIR_DOMAIN_PARAM_LIVE;
} else {
- if (flags == VIR_DOMAIN_DEVICE_MODIFY_CURRENT)
- flags |= VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+ if (flags == VIR_DOMAIN_PARAM_CURRENT)
+ flags |= VIR_DOMAIN_PARAM_CONFIG;
/* check consistency between flags and the vm state */
- if (flags & VIR_DOMAIN_DEVICE_MODIFY_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
qemuReportError(VIR_ERR_OPERATION_INVALID,
"%s",
_("cannot do live update a device on "
@@ -4443,13 +4443,13 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
}
}
- if ((flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) && !vm->persistent) {
+ if ((flags & VIR_DOMAIN_PARAM_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_PARAM_CONFIG) {
dev = virDomainDeviceDefParse(driver->caps, vm->def, xml,
VIR_DOMAIN_XML_INACTIVE);
if (dev == NULL)
@@ -4477,7 +4477,7 @@ qemuDomainModifyDeviceFlags(virDomainPtr dom, const char *xml,
} else
ret = 0;
- if (!ret && (flags & VIR_DOMAIN_DEVICE_MODIFY_LIVE)) {
+ if (!ret && (flags & VIR_DOMAIN_PARAM_LIVE)) {
/* If dev exists it was created to modify the domain config. Free it. */
virDomainDeviceDefFree(dev);
dev = virDomainDeviceDefParse(driver->caps, vm->def, xml,
@@ -4509,7 +4509,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_PARAM_CONFIG)) {
ret = virDomainSaveConfig(driver->configDir, vmdef);
if (!ret) {
virDomainObjAssignDef(vm, vmdef, false);
@@ -4539,7 +4539,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_PARAM_LIVE);
}
@@ -4559,7 +4559,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_PARAM_LIVE);
}
static int qemudDomainGetAutostart(virDomainPtr dom,
@@ -4870,8 +4870,8 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
int ret = -1;
bool isActive;
- virCheckFlags(VIR_DOMAIN_MEMORY_PARAM_LIVE |
- VIR_DOMAIN_MEMORY_PARAM_CONFIG, -1);
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG, -1);
qemuDriverLock(driver);
@@ -4885,14 +4885,14 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
isActive = virDomainObjIsActive(vm);
- if (flags == VIR_DOMAIN_MEMORY_PARAM_CURRENT) {
+ if (flags == VIR_DOMAIN_PARAM_CURRENT) {
if (isActive)
- flags = VIR_DOMAIN_MEMORY_PARAM_LIVE;
+ flags = VIR_DOMAIN_PARAM_LIVE;
else
- flags = VIR_DOMAIN_MEMORY_PARAM_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
if (!isActive) {
qemuReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("domain is not running"));
@@ -4912,7 +4912,7 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
}
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
if (!vm->persistent) {
qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("cannot change persistent config of a transient domain"));
@@ -4935,7 +4935,7 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
continue;
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
rc = virCgroupSetMemoryHardLimit(group, params[i].value.ul);
if (rc != 0) {
virReportSystemError(-rc, "%s",
@@ -4944,7 +4944,7 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
}
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
persistentDef->mem.hard_limit = params[i].value.ul;
}
} else if (STREQ(param->field, VIR_DOMAIN_MEMORY_SOFT_LIMIT)) {
@@ -4956,7 +4956,7 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
continue;
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
rc = virCgroupSetMemorySoftLimit(group, params[i].value.ul);
if (rc != 0) {
virReportSystemError(-rc, "%s",
@@ -4965,7 +4965,7 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
}
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
persistentDef->mem.soft_limit = params[i].value.ul;
}
} else if (STREQ(param->field, VIR_DOMAIN_MEMORY_SWAP_HARD_LIMIT)) {
@@ -4977,7 +4977,7 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
continue;
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
rc = virCgroupSetMemSwapHardLimit(group, params[i].value.ul);
if (rc != 0) {
virReportSystemError(-rc, "%s",
@@ -4985,7 +4985,7 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
ret = -1;
}
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
persistentDef->mem.swap_hard_limit = params[i].value.ul;
}
} else if (STREQ(param->field, VIR_DOMAIN_MEMORY_MIN_GUARANTEE)) {
@@ -4999,7 +4999,7 @@ static int qemuDomainSetMemoryParameters(virDomainPtr dom,
}
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
ret = virDomainSaveConfig(driver->configDir, persistentDef);
}
@@ -5026,8 +5026,8 @@ static int qemuDomainGetMemoryParameters(virDomainPtr dom,
int rc;
bool isActive;
- virCheckFlags(VIR_DOMAIN_MEMORY_PARAM_LIVE |
- VIR_DOMAIN_MEMORY_PARAM_CONFIG, -1);
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG, -1);
qemuDriverLock(driver);
@@ -5041,14 +5041,14 @@ static int qemuDomainGetMemoryParameters(virDomainPtr dom,
isActive = virDomainObjIsActive(vm);
- if (flags == VIR_DOMAIN_MEMORY_PARAM_CURRENT) {
+ if (flags == VIR_DOMAIN_PARAM_CURRENT) {
if (isActive)
- flags = VIR_DOMAIN_MEMORY_PARAM_LIVE;
+ flags = VIR_DOMAIN_PARAM_LIVE;
else
- flags = VIR_DOMAIN_MEMORY_PARAM_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
if (!isActive) {
qemuReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("domain is not running"));
@@ -5068,7 +5068,7 @@ static int qemuDomainGetMemoryParameters(virDomainPtr dom,
}
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
if (!vm->persistent) {
qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("cannot change persistent config of a transient domain"));
@@ -5091,7 +5091,7 @@ static int qemuDomainGetMemoryParameters(virDomainPtr dom,
goto cleanup;
}
- if (flags & VIR_DOMAIN_MEMORY_PARAM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
for (i = 0; i < *nparams; i++) {
virMemoryParameterPtr param = ¶ms[i];
val = 0;
@@ -5218,8 +5218,8 @@ static int qemuSetSchedulerParametersFlags(virDomainPtr dom,
int ret = -1;
bool isActive;
- virCheckFlags(VIR_DOMAIN_SCHEDPARAM_LIVE |
- VIR_DOMAIN_SCHEDPARAM_CONFIG, -1);
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG, -1);
qemuDriverLock(driver);
@@ -5233,20 +5233,20 @@ static int qemuSetSchedulerParametersFlags(virDomainPtr dom,
isActive = virDomainObjIsActive(vm);
- if (flags == VIR_DOMAIN_SCHEDPARAM_CURRENT) {
+ if (flags == VIR_DOMAIN_PARAM_CURRENT) {
if (isActive)
- flags = VIR_DOMAIN_SCHEDPARAM_LIVE;
+ flags = VIR_DOMAIN_PARAM_LIVE;
else
- flags = VIR_DOMAIN_SCHEDPARAM_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
}
- if ((flags & VIR_DOMAIN_SCHEDPARAM_CONFIG) && !vm->persistent) {
+ if ((flags & VIR_DOMAIN_PARAM_CONFIG) && !vm->persistent) {
qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("cannot change persistent config of a transient domain"));
goto cleanup;
}
- if (flags & VIR_DOMAIN_SCHEDPARAM_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
if (!isActive) {
qemuReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("domain is not running"));
@@ -5277,7 +5277,7 @@ static int qemuSetSchedulerParametersFlags(virDomainPtr dom,
goto cleanup;
}
- if (flags & VIR_DOMAIN_SCHEDPARAM_LIVE) {
+ if (flags & VIR_DOMAIN_PARAM_LIVE) {
rc = virCgroupSetCpuShares(group, params[i].value.ul);
if (rc != 0) {
virReportSystemError(-rc, "%s",
@@ -5288,7 +5288,7 @@ static int qemuSetSchedulerParametersFlags(virDomainPtr dom,
vm->def->cputune.shares = params[i].value.ul;
}
- if (flags & VIR_DOMAIN_SCHEDPARAM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
persistentDef = virDomainObjGetPersistentDef(driver->caps, vm);
if (!persistentDef) {
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@@ -5327,7 +5327,7 @@ static int qemuSetSchedulerParameters(virDomainPtr dom,
return qemuSetSchedulerParametersFlags(dom,
params,
nparams,
- VIR_DOMAIN_SCHEDPARAM_LIVE);
+ VIR_DOMAIN_PARAM_LIVE);
}
static int
@@ -5344,11 +5344,11 @@ qemuGetSchedulerParametersFlags(virDomainPtr dom,
int rc;
bool isActive;
- virCheckFlags(VIR_DOMAIN_SCHEDPARAM_LIVE |
- VIR_DOMAIN_SCHEDPARAM_CONFIG, -1);
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG, -1);
- if ((flags & (VIR_DOMAIN_SCHEDPARAM_LIVE | VIR_DOMAIN_SCHEDPARAM_CONFIG)) ==
- (VIR_DOMAIN_SCHEDPARAM_LIVE | VIR_DOMAIN_SCHEDPARAM_CONFIG)) {
+ if ((flags & (VIR_DOMAIN_PARAM_LIVE | VIR_DOMAIN_PARAM_CONFIG)) ==
+ (VIR_DOMAIN_PARAM_LIVE | VIR_DOMAIN_PARAM_CONFIG)) {
qemuReportError(VIR_ERR_INVALID_ARG, "%s",
_("cannot query live and config together"));
goto cleanup;
@@ -5371,14 +5371,14 @@ qemuGetSchedulerParametersFlags(virDomainPtr dom,
isActive = virDomainObjIsActive(vm);
- if (flags == VIR_DOMAIN_SCHEDPARAM_CURRENT) {
+ if (flags == VIR_DOMAIN_PARAM_CURRENT) {
if (isActive)
- flags = VIR_DOMAIN_SCHEDPARAM_LIVE;
+ flags = VIR_DOMAIN_PARAM_LIVE;
else
- flags = VIR_DOMAIN_SCHEDPARAM_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
}
- if (flags & VIR_DOMAIN_SCHEDPARAM_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_CONFIG) {
if (!vm->persistent) {
qemuReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("cannot query persistent config of a transient domain"));
@@ -5451,7 +5451,7 @@ qemuGetSchedulerParameters(virDomainPtr dom,
int *nparams)
{
return qemuGetSchedulerParametersFlags(dom, params, nparams,
- VIR_DOMAIN_SCHEDPARAM_CURRENT);
+ VIR_DOMAIN_PARAM_CURRENT);
}
/* This uses the 'info blockstats' monitor command which was
diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index 2da24f1..b996ee1 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 |
- VIR_DOMAIN_VCPU_MAXIMUM, -1);
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG |
+ VIR_DOMAIN_PARAM_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_PARAM_LIVE) == !(flags & VIR_DOMAIN_PARAM_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_PARAM_LIVE) {
if (!virDomainObjIsActive(vm)) {
testError(VIR_ERR_OPERATION_INVALID, "%s",
_("domain not active"));
@@ -2100,7 +2100,7 @@ testDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
def = vm->newDef ? vm->newDef : vm->def;
}
- ret = (flags & VIR_DOMAIN_VCPU_MAXIMUM) ? def->maxvcpus : def->vcpus;
+ ret = (flags & VIR_DOMAIN_PARAM_MAXIMUM) ? def->maxvcpus : def->vcpus;
cleanup:
if (vm)
@@ -2111,8 +2111,8 @@ cleanup:
static int
testDomainGetMaxVcpus(virDomainPtr domain)
{
- return testDomainGetVcpusFlags(domain, (VIR_DOMAIN_VCPU_LIVE |
- VIR_DOMAIN_VCPU_MAXIMUM));
+ return testDomainGetVcpusFlags(domain, (VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_MAXIMUM));
}
static int
@@ -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 |
- VIR_DOMAIN_VCPU_MAXIMUM, -1);
+ virCheckFlags(VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG |
+ VIR_DOMAIN_PARAM_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_PARAM_LIVE | VIR_DOMAIN_PARAM_CONFIG)) == 0 ||
+ (flags & (VIR_DOMAIN_PARAM_MAXIMUM | VIR_DOMAIN_PARAM_LIVE)) ==
+ (VIR_DOMAIN_PARAM_MAXIMUM | VIR_DOMAIN_PARAM_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_PARAM_LIVE)) {
testError(VIR_ERR_OPERATION_INVALID,
"%s", _("cannot hotplug vcpus for an inactive domain"));
goto cleanup;
@@ -2160,7 +2160,7 @@ testDomainSetVcpusFlags(virDomainPtr domain, unsigned int nrCpus,
/* We allow more cpus in guest than host, but not more than the
* domain's starting limit. */
- if (!(flags & (VIR_DOMAIN_VCPU_MAXIMUM)) &&
+ if (!(flags & (VIR_DOMAIN_PARAM_MAXIMUM)) &&
privdom->def->maxvcpus < maxvcpus)
maxvcpus = privdom->def->maxvcpus;
@@ -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_PARAM_MAXIMUM | VIR_DOMAIN_PARAM_CONFIG:
persistentDef->maxvcpus = nrCpus;
if (nrCpus < persistentDef->vcpus)
persistentDef->vcpus = nrCpus;
ret = 0;
break;
- case VIR_DOMAIN_VCPU_CONFIG:
+ case VIR_DOMAIN_PARAM_CONFIG:
persistentDef->vcpus = nrCpus;
ret = 0;
break;
- case VIR_DOMAIN_VCPU_LIVE:
+ case VIR_DOMAIN_PARAM_LIVE:
ret = testDomainUpdateVCPUs(domain->conn, privdom, nrCpus, 0);
break;
- case VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_CONFIG:
+ case VIR_DOMAIN_PARAM_LIVE | VIR_DOMAIN_PARAM_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_PARAM_LIVE);
}
static int testDomainGetVcpus(virDomainPtr domain,
diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c
index 536cd8c..0991f1e 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_PARAM_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_PARAM_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..22c842c 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_PARAM_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_PARAM_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_PARAM_LIVE | VIR_DOMAIN_PARAM_MAXIMUM)) {
vboxError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"), flags);
return -1;
}
@@ -2127,8 +2127,8 @@ vboxDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
static int
vboxDomainGetMaxVcpus(virDomainPtr dom)
{
- return vboxDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE |
- VIR_DOMAIN_VCPU_MAXIMUM));
+ return vboxDomainGetVcpusFlags(dom, (VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_MAXIMUM));
}
static char *vboxDomainGetXMLDesc(virDomainPtr dom, int flags) {
@@ -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_PARAM_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_PARAM_CURRENT |
+ VIR_DOMAIN_PARAM_LIVE |
+ VIR_DOMAIN_PARAM_CONFIG, -1);
- if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
+ if (flags & VIR_DOMAIN_PARAM_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_PARAM_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 dfd5bd2..e47f9fe 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -1729,12 +1729,12 @@ cmdSchedinfo(vshControl *ctl, const vshCmd *cmd)
vshError(ctl, "%s", _("--current must be specified exclusively"));
return false;
}
- flags = VIR_DOMAIN_SCHEDPARAM_CURRENT;
+ flags = VIR_DOMAIN_PARAM_CURRENT;
} else {
if (config)
- flags |= VIR_DOMAIN_SCHEDPARAM_CONFIG;
+ flags |= VIR_DOMAIN_PARAM_CONFIG;
if (live)
- flags |= VIR_DOMAIN_SCHEDPARAM_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
}
if (!vshConnectionUsability(ctl, ctl->conn))
@@ -2567,8 +2567,8 @@ cmdVcpucount(vshControl *ctl, const vshCmd *cmd)
* talking to an older client, try a fallback API before giving
* up. */
if (all || (maximum && config)) {
- count = virDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_MAXIMUM |
- VIR_DOMAIN_VCPU_CONFIG));
+ count = virDomainGetVcpusFlags(dom, (VIR_DOMAIN_PARAM_MAXIMUM |
+ VIR_DOMAIN_PARAM_CONFIG));
if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT
|| last_error->code == VIR_ERR_INVALID_ARG)) {
char *tmp;
@@ -2597,8 +2597,8 @@ cmdVcpucount(vshControl *ctl, const vshCmd *cmd)
}
if (all || (maximum && live)) {
- count = virDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_MAXIMUM |
- VIR_DOMAIN_VCPU_LIVE));
+ count = virDomainGetVcpusFlags(dom, (VIR_DOMAIN_PARAM_MAXIMUM |
+ VIR_DOMAIN_PARAM_LIVE));
if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT
|| last_error->code == VIR_ERR_INVALID_ARG)) {
count = virDomainGetMaxVcpus(dom);
@@ -2618,7 +2618,7 @@ cmdVcpucount(vshControl *ctl, const vshCmd *cmd)
}
if (all || (current && config)) {
- count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_VCPU_CONFIG);
+ count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_PARAM_CONFIG);
if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT
|| last_error->code == VIR_ERR_INVALID_ARG)) {
char *tmp, *end;
@@ -2655,7 +2655,7 @@ cmdVcpucount(vshControl *ctl, const vshCmd *cmd)
}
if (all || (current && live)) {
- count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_VCPU_LIVE);
+ count = virDomainGetVcpusFlags(dom, VIR_DOMAIN_PARAM_LIVE);
if (count < 0 && (last_error->code == VIR_ERR_NO_SUPPORT
|| last_error->code == VIR_ERR_INVALID_ARG)) {
virDomainInfo info;
@@ -2927,9 +2927,9 @@ cmdSetvcpus(vshControl *ctl, const vshCmd *cmd)
int maximum = vshCommandOptBool(cmd, "maximum");
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));
+ int flags = ((maximum ? VIR_DOMAIN_PARAM_MAXIMUM : 0) |
+ (config ? VIR_DOMAIN_PARAM_CONFIG : 0) |
+ (live ? VIR_DOMAIN_PARAM_LIVE : 0));
if (!vshConnectionUsability(ctl, ctl->conn))
return false;
@@ -3045,12 +3045,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_PARAM_CURRENT;
} else {
if (config)
- flags |= VIR_DOMAIN_MEM_CONFIG;
+ flags |= VIR_DOMAIN_PARAM_CONFIG;
if (live)
- flags |= VIR_DOMAIN_MEM_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
/* neither option is specified */
if (!live && !config)
flags = -1;
@@ -3127,7 +3127,7 @@ cmdSetmaxmem(vshControl *ctl, const vshCmd *cmd)
int config = vshCommandOptBool(cmd, "config");
int live = vshCommandOptBool(cmd, "live");
int current = vshCommandOptBool(cmd, "current");
- int flags = VIR_DOMAIN_MEM_MAXIMUM;
+ int flags = VIR_DOMAIN_PARAM_MAXIMUM;
if (current) {
if (live || config) {
@@ -3136,9 +3136,9 @@ cmdSetmaxmem(vshControl *ctl, const vshCmd *cmd)
}
} else {
if (config)
- flags |= VIR_DOMAIN_MEM_CONFIG;
+ flags |= VIR_DOMAIN_PARAM_CONFIG;
if (live)
- flags |= VIR_DOMAIN_MEM_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
/* neither option is specified */
if (!live && !config)
flags = -1;
@@ -3355,12 +3355,12 @@ cmdMemtune(vshControl * ctl, const vshCmd * cmd)
vshError(ctl, "%s", _("--current must be specified exclusively"));
return false;
}
- flags = VIR_DOMAIN_MEMORY_PARAM_CURRENT;
+ flags = VIR_DOMAIN_PARAM_CURRENT;
} else {
if (config)
- flags |= VIR_DOMAIN_MEMORY_PARAM_CONFIG;
+ flags |= VIR_DOMAIN_PARAM_CONFIG;
if (live)
- flags |= VIR_DOMAIN_MEMORY_PARAM_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
}
if (!vshConnectionUsability(ctl, ctl->conn))
@@ -9141,9 +9141,9 @@ cmdAttachDevice(vshControl *ctl, const vshCmd *cmd)
}
if (vshCommandOptBool(cmd, "persistent")) {
- flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
if (virDomainIsActive(dom) == 1)
- flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
ret = virDomainAttachDeviceFlags(dom, buffer, flags);
} else {
ret = virDomainAttachDevice(dom, buffer);
@@ -9206,9 +9206,9 @@ cmdDetachDevice(vshControl *ctl, const vshCmd *cmd)
}
if (vshCommandOptBool(cmd, "persistent")) {
- flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
if (virDomainIsActive(dom) == 1)
- flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
ret = virDomainDetachDeviceFlags(dom, buffer, flags);
} else {
ret = virDomainDetachDevice(dom, buffer);
@@ -9272,15 +9272,15 @@ cmdUpdateDevice(vshControl *ctl, const vshCmd *cmd)
}
if (vshCommandOptBool(cmd, "persistent")) {
- flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
if (virDomainIsActive(dom) == 1)
- flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
} else {
- flags = VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+ flags = VIR_DOMAIN_PARAM_LIVE;
}
if (vshCommandOptBool(cmd, "force"))
- flags |= VIR_DOMAIN_DEVICE_MODIFY_FORCE;
+ flags |= VIR_DOMAIN_PARAM_FORCE;
ret = virDomainUpdateDeviceFlags(dom, buffer, flags);
VIR_FREE(buffer);
@@ -9388,9 +9388,9 @@ cmdAttachInterface(vshControl *ctl, const vshCmd *cmd)
xml = virBufferContentAndReset(&buf);
if (vshCommandOptBool(cmd, "persistent")) {
- flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
if (virDomainIsActive(dom) == 1)
- flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
ret = virDomainAttachDeviceFlags(dom, xml, flags);
} else {
ret = virDomainAttachDevice(dom, xml);
@@ -9527,9 +9527,9 @@ cmdDetachInterface(vshControl *ctl, const vshCmd *cmd)
}
if (vshCommandOptBool(cmd, "persistent")) {
- flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
if (virDomainIsActive(dom) == 1)
- flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
ret = virDomainDetachDeviceFlags(dom,
(char *)xmlBufferContent(xml_buf),
flags);
@@ -9665,9 +9665,9 @@ cmdAttachDisk(vshControl *ctl, const vshCmd *cmd)
xml = virBufferContentAndReset(&buf);
if (vshCommandOptBool(cmd, "persistent")) {
- flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
if (virDomainIsActive(dom) == 1)
- flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
ret = virDomainAttachDeviceFlags(dom, xml, flags);
} else {
ret = virDomainAttachDevice(dom, xml);
@@ -9787,9 +9787,9 @@ cmdDetachDisk(vshControl *ctl, const vshCmd *cmd)
}
if (vshCommandOptBool(cmd, "persistent")) {
- flags = VIR_DOMAIN_DEVICE_MODIFY_CONFIG;
+ flags = VIR_DOMAIN_PARAM_CONFIG;
if (virDomainIsActive(dom) == 1)
- flags |= VIR_DOMAIN_DEVICE_MODIFY_LIVE;
+ flags |= VIR_DOMAIN_PARAM_LIVE;
ret = virDomainDetachDeviceFlags(dom,
(char *)xmlBufferContent(xml_buf),
flags);
--
1.7.3.1
--
libvir-list mailing list
libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list