if (virDomainGetXMLDescEnsureACL(domain->conn, vm->def, flags) < 0)
goto cleanup;
- ret = virDomainDefFormat(vm->def, flags);
+ ret = virDomainDefFormat(vm->def,
+ virDomainDefFormatConvertXMLFlags(flags));
cleanup:
if (vm)
if ((def = virDomainDefParseString(xml, caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_BHYVE,
- VIR_DOMAIN_XML_INACTIVE)) == NULL)
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)) == NULL)
goto cleanup;
if (virDomainDefineXMLFlagsEnsureACL(conn, def) < 0)
if (!(def = virDomainDefParseString(xmlData, caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_BHYVE,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (bhyveDomainAssignAddresses(def, NULL) < 0)
if ((def = virDomainDefParseString(xml, caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_BHYVE,
- VIR_DOMAIN_XML_INACTIVE)) == NULL)
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)) == NULL)
goto cleanup;
if (virDomainCreateXMLEnsureACL(conn, def) < 0)
/* XML namespace callbacks */
virDomainXMLNamespace ns;
- };
-
-
-/* Private flags used internally by virDomainSaveStatus and
- * virDomainLoadStatus, in addition to the public virDomainXMLFlags. */
-typedef enum {
- /* dump internal domain status information */
- VIR_DOMAIN_XML_INTERNAL_STATUS = 1 << 16,
- /* dump/parse <actual> element */
- VIR_DOMAIN_XML_INTERNAL_ACTUAL_NET = 1 << 17,
- /* dump/parse original states of host PCI device */
- VIR_DOMAIN_XML_INTERNAL_PCI_ORIG_STATES = 1 << 18,
- VIR_DOMAIN_XML_INTERNAL_ALLOW_ROM = 1 << 19,
- VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT = 1 << 20,
- VIR_DOMAIN_XML_INTERNAL_CLOCK_ADJUST = 1 << 21,
- /* parse only source half of <disk> */
- VIR_DOMAIN_XML_INTERNAL_DISK_SOURCE = 1 << 22,
-} virDomainXMLInternalFlags;
-
-#define DUMPXML_FLAGS \
- (VIR_DOMAIN_XML_SECURE | \
- VIR_DOMAIN_XML_INACTIVE | \
- VIR_DOMAIN_XML_UPDATE_CPU | \
- VIR_DOMAIN_XML_MIGRATABLE)
-
-verify(((VIR_DOMAIN_XML_INTERNAL_STATUS |
- VIR_DOMAIN_XML_INTERNAL_ACTUAL_NET |
- VIR_DOMAIN_XML_INTERNAL_PCI_ORIG_STATES |
- VIR_DOMAIN_XML_INTERNAL_ALLOW_ROM |
- VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT |
- VIR_DOMAIN_XML_INTERNAL_CLOCK_ADJUST |
- VIR_DOMAIN_XML_INTERNAL_DISK_SOURCE)
- & DUMPXML_FLAGS) == 0);
+};
+
+#define VIR_DOMAIN_DEF_FORMAT_COMMON_FLAGS \
+ (VIR_DOMAIN_DEF_FORMAT_SECURE | \
+ VIR_DOMAIN_DEF_FORMAT_INACTIVE | \
+ VIR_DOMAIN_DEF_FORMAT_UPDATE_CPU | \
+ VIR_DOMAIN_DEF_FORMAT_MIGRATABLE)
VIR_ENUM_IMPL(virDomainTaint, VIR_DOMAIN_TAINT_LAST,
"custom-argv",
VIR_ENUM_IMPL(virDomainBlockJob, VIR_DOMAIN_BLOCK_JOB_TYPE_LAST,
"", "", "copy", "", "active-commit")
-#define VIR_DOMAIN_XML_WRITE_FLAGS VIR_DOMAIN_XML_SECURE
-#define VIR_DOMAIN_XML_READ_FLAGS VIR_DOMAIN_XML_INACTIVE
-
static virClassPtr virDomainObjClass;
static virClassPtr virDomainObjListClass;
static virClassPtr virDomainXMLOptionClass;
}
static bool
-virDomainDeviceInfoIsSet(virDomainDeviceInfoPtr info, unsigned int flags)
+virDomainDeviceInfoNeedsFormat(virDomainDeviceInfoPtr info, unsigned int flags)
{
if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
return true;
- if (info->alias && !(flags & VIR_DOMAIN_XML_INACTIVE))
+ if (info->alias && !(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE))
return true;
if (info->mastertype != VIR_DOMAIN_CONTROLLER_MASTER_NONE)
return true;
virDomainDeviceInfoPtr info,
unsigned int flags)
{
- if ((flags & VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT) && info->bootIndex)
+ if ((flags & VIR_DOMAIN_DEF_FORMAT_ALLOW_BOOT) && info->bootIndex)
virBufferAsprintf(buf, "<boot order='%d'/>\n", info->bootIndex);
if (info->alias &&
- !(flags & VIR_DOMAIN_XML_INACTIVE)) {
+ !(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE)) {
virBufferAsprintf(buf, "<alias name='%s'/>\n", info->alias);
}
info->master.usb.startport);
}
- if ((flags & VIR_DOMAIN_XML_INTERNAL_ALLOW_ROM) &&
+ if ((flags & VIR_DOMAIN_DEF_FORMAT_ALLOW_ROM) &&
(info->rombar || info->romfile)) {
virBufferAddLit(buf, "<rom");
while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE) {
if (alias == NULL &&
- !(flags & VIR_DOMAIN_XML_INACTIVE) &&
+ !(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE) &&
xmlStrEqual(cur->name, BAD_CAST "alias")) {
alias = cur;
} else if (address == NULL &&
xmlStrEqual(cur->name, BAD_CAST "master")) {
master = cur;
} else if (boot == NULL &&
- (flags & VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT) &&
+ (flags & VIR_DOMAIN_DEF_PARSE_ALLOW_BOOT) &&
xmlStrEqual(cur->name, BAD_CAST "boot")) {
boot = cur;
} else if (rom == NULL &&
- (flags & VIR_DOMAIN_XML_INTERNAL_ALLOW_ROM) &&
+ (flags & VIR_DOMAIN_DEF_PARSE_ALLOW_ROM) &&
xmlStrEqual(cur->name, BAD_CAST "rom")) {
rom = cur;
}
if (virDevicePCIAddressParseXML(cur, addr) < 0)
goto out;
- } else if ((flags & VIR_DOMAIN_XML_INTERNAL_STATUS) &&
+ } else if ((flags & VIR_DOMAIN_DEF_PARSE_STATUS) &&
xmlStrEqual(cur->name, BAD_CAST "state")) {
/* Legacy back-compat. Don't add any more attributes here */
char *devaddr = virXMLPropString(cur, "devaddr");
goto out;
}
def->info->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
- } else if ((flags & VIR_DOMAIN_XML_INTERNAL_PCI_ORIG_STATES) &&
+ } else if ((flags & VIR_DOMAIN_DEF_PARSE_PCI_ORIG_STATES) &&
xmlStrEqual(cur->name, BAD_CAST "origstates")) {
virDomainHostdevOrigStatesPtr states = &def->origstates;
if (virDomainHostdevSubsysPCIOrigStatesDefParseXML(cur, states) < 0)
* present. Hence, return now. */
if (STREQ_NULLABLE(seclabel->model, "none")) {
- if (flags & VIR_DOMAIN_XML_INACTIVE) {
+ if (flags & VIR_DOMAIN_DEF_PARSE_INACTIVE) {
/* Fix older configurations */
seclabel->type = VIR_DOMAIN_SECLABEL_NONE;
seclabel->relabel = false;
* if the 'live' VM XML is requested
*/
if (seclabel->type == VIR_DOMAIN_SECLABEL_STATIC ||
- (!(flags & VIR_DOMAIN_XML_INACTIVE) &&
+ (!(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE) &&
seclabel->type != VIR_DOMAIN_SECLABEL_NONE)) {
p = virXPathStringLimit("string(./label[1])",
VIR_SECURITY_LABEL_BUFLEN-1, ctxt);
/* Only parse imagelabel, if requested live XML with relabeling */
if (seclabel->relabel &&
- (!(flags & VIR_DOMAIN_XML_INACTIVE) &&
+ (!(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE) &&
seclabel->type != VIR_DOMAIN_SECLABEL_NONE)) {
p = virXPathStringLimit("string(./imagelabel[1])",
VIR_SECURITY_LABEL_BUFLEN-1, ctxt);
if (def->seclabels[0]->type == VIR_DOMAIN_SECLABEL_NONE ||
(def->seclabels[0]->type == VIR_DOMAIN_SECLABEL_DYNAMIC &&
!def->seclabels[0]->baselabel &&
- (flags & VIR_DOMAIN_XML_INACTIVE))) {
+ (flags & VIR_DOMAIN_DEF_PARSE_INACTIVE))) {
/* Copy model from host. */
VIR_DEBUG("Found seclabel without a model, using '%s'",
host->secModels[0].model);
goto error;
if (STREQ(def->seclabels[0]->model, "none") &&
- flags & VIR_DOMAIN_XML_INACTIVE) {
+ flags & VIR_DOMAIN_DEF_PARSE_INACTIVE) {
/* Fix older configurations */
def->seclabels[0]->type = VIR_DOMAIN_SECLABEL_NONE;
def->seclabels[0]->relabel = false;
/* labelskip is only parsed on live images */
labelskip = virXMLPropString(list[i], "labelskip");
seclabels[i]->labelskip = false;
- if (labelskip && !(flags & VIR_DOMAIN_XML_INACTIVE))
+ if (labelskip && !(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE))
seclabels[i]->labelskip = STREQ(labelskip, "yes");
VIR_FREE(labelskip);
driverIOThread = virXMLPropString(cur, "iothread");
} else if (!def->mirror &&
xmlStrEqual(cur->name, BAD_CAST "mirror") &&
- !(flags & VIR_DOMAIN_XML_INACTIVE)) {
+ !(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE)) {
char *ready;
char *blockJob;
def->src->shared = true;
} else if (xmlStrEqual(cur->name, BAD_CAST "transient")) {
def->transient = true;
- } else if ((flags & VIR_DOMAIN_XML_INTERNAL_STATUS) &&
+ } else if ((flags & VIR_DOMAIN_DEF_PARSE_STATUS) &&
xmlStrEqual(cur->name, BAD_CAST "state")) {
/* Legacy back-compat. Don't add any more attributes here */
devaddr = virXMLPropString(cur, "devaddr");
* that are not attached to a physical device presently */
if (source == NULL && def->src->hosts == NULL && !def->src->srcpool &&
(def->device == VIR_DOMAIN_DISK_DEVICE_DISK ||
- (flags & VIR_DOMAIN_XML_INTERNAL_DISK_SOURCE))) {
+ (flags & VIR_DOMAIN_DEF_PARSE_DISK_SOURCE))) {
virReportError(VIR_ERR_NO_SOURCE,
target ? "%s" : NULL, target);
goto error;
ctxt->node = saved_node;
}
- if (!target && !(flags & VIR_DOMAIN_XML_INTERNAL_DISK_SOURCE)) {
+ if (!target && !(flags & VIR_DOMAIN_DEF_PARSE_DISK_SOURCE)) {
if (def->src->srcpool) {
char *tmp;
if (virAsprintf(&tmp, "pool = '%s', volume = '%s'",
goto error;
}
- if (!(flags & VIR_DOMAIN_XML_INTERNAL_DISK_SOURCE)) {
+ if (!(flags & VIR_DOMAIN_DEF_PARSE_DISK_SOURCE)) {
if (def->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
!STRPREFIX(target, "fd")) {
virReportError(VIR_ERR_INTERNAL_ERROR,
} else {
if (def->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
def->bus = VIR_DOMAIN_DISK_BUS_FDC;
- } else if (!(flags & VIR_DOMAIN_XML_INTERNAL_DISK_SOURCE)) {
+ } else if (!(flags & VIR_DOMAIN_DEF_PARSE_DISK_SOURCE)) {
if (STRPREFIX(target, "hd"))
def->bus = VIR_DOMAIN_DISK_BUS_IDE;
else if (STRPREFIX(target, "sd"))
def->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
} else {
if (virDomainDeviceInfoParseXML(node, bootHash, &def->info,
- flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT) < 0)
+ flags | VIR_DOMAIN_DEF_PARSE_ALLOW_BOOT) < 0)
goto error;
}
}
}
- if (!(flags & VIR_DOMAIN_XML_INTERNAL_DISK_SOURCE)) {
+ if (!(flags & VIR_DOMAIN_DEF_PARSE_DISK_SOURCE)) {
if (def->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE
&& virDomainDiskDefAssignAddress(xmlopt, def) < 0)
goto error;
xmlStrEqual(cur->name, BAD_CAST "target")) {
ifname = virXMLPropString(cur, "dev");
if (ifname &&
- (flags & VIR_DOMAIN_XML_INACTIVE) &&
+ (flags & VIR_DOMAIN_DEF_PARSE_INACTIVE) &&
STRPREFIX(ifname, VIR_NET_GENERATED_PREFIX)) {
/* An auto-generated target name, blank it out */
VIR_FREE(ifname);
filter = virXMLPropString(cur, "filter");
virNWFilterHashTableFree(filterparams);
filterparams = virNWFilterParseParamAttributes(cur);
- } else if ((flags & VIR_DOMAIN_XML_INTERNAL_STATUS) &&
+ } else if ((flags & VIR_DOMAIN_DEF_PARSE_STATUS) &&
xmlStrEqual(cur->name, BAD_CAST "state")) {
/* Legacy back-compat. Don't add any more attributes here */
devaddr = virXMLPropString(cur, "devaddr");
} else if (xmlStrEqual(cur->name, BAD_CAST "boot")) {
/* boot is parsed as part of virDomainDeviceInfoParseXML */
} else if (!actual &&
- (flags & VIR_DOMAIN_XML_INTERNAL_ACTUAL_NET) &&
+ (flags & VIR_DOMAIN_DEF_PARSE_ACTUAL_NET) &&
def->type == VIR_DOMAIN_NET_TYPE_NETWORK &&
xmlStrEqual(cur->name, BAD_CAST "actual")) {
if (virDomainActualNetDefParseXML(cur, ctxt, def,
def->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
} else {
if (virDomainDeviceInfoParseXML(node, bootHash, &def->info,
- flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT
- | VIR_DOMAIN_XML_INTERNAL_ALLOW_ROM) < 0)
+ flags | VIR_DOMAIN_DEF_PARSE_ALLOW_BOOT
+ | VIR_DOMAIN_DEF_PARSE_ALLOW_ROM) < 0)
goto error;
}
def->data.direct.linkdev = dev;
dev = NULL;
- if (flags & VIR_DOMAIN_XML_INACTIVE)
+ if (flags & VIR_DOMAIN_DEF_PARSE_INACTIVE)
VIR_FREE(ifname);
break;
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
def->target.name = virXMLPropString(cur, "name");
- if (!(flags & VIR_DOMAIN_XML_INACTIVE) &&
+ if (!(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE) &&
(stateStr = virXMLPropString(cur, "state"))) {
int tmp;
/* PTY path is only parsed from live xml. */
if (!path &&
(def->type != VIR_DOMAIN_CHR_TYPE_PTY ||
- !(flags & VIR_DOMAIN_XML_INACTIVE)))
+ !(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE)))
path = virXMLPropString(cur, "path");
break;
if (address && address[0] &&
(def->type == VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS ||
(def->type == VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK &&
- !(flags & VIR_DOMAIN_XML_INACTIVE)))) {
+ !(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE)))) {
def->address = address;
address = NULL;
}
}
if (fromConfig &&
- flags & VIR_DOMAIN_XML_INTERNAL_STATUS) {
+ flags & VIR_DOMAIN_DEF_PARSE_STATUS) {
if (virStrToLong_i(fromConfig, NULL, 10, &tmp) < 0) {
virReportError(VIR_ERR_XML_ERROR,
_("Invalid fromConfig value: %s"),
VIR_FREE(port);
/* Legacy compat syntax, used -1 for auto-port */
if (def->data.vnc.port == -1) {
- if (flags & VIR_DOMAIN_XML_INACTIVE)
+ if (flags & VIR_DOMAIN_DEF_PARSE_INACTIVE)
def->data.vnc.port = 0;
def->data.vnc.autoport = true;
}
if ((autoport = virXMLPropString(node, "autoport")) != NULL) {
if (STREQ(autoport, "yes")) {
- if (flags & VIR_DOMAIN_XML_INACTIVE)
+ if (flags & VIR_DOMAIN_DEF_PARSE_INACTIVE)
def->data.vnc.port = 0;
def->data.vnc.autoport = true;
}
VIR_FREE(autoport);
}
- if (def->data.rdp.autoport && (flags & VIR_DOMAIN_XML_INACTIVE))
+ if (def->data.rdp.autoport && (flags & VIR_DOMAIN_DEF_PARSE_INACTIVE))
def->data.rdp.port = 0;
if ((replaceUser = virXMLPropString(node, "replaceUser")) != NULL) {
def->data.spice.autoport = true;
}
- if (def->data.spice.autoport && (flags & VIR_DOMAIN_XML_INACTIVE)) {
+ if (def->data.spice.autoport && (flags & VIR_DOMAIN_DEF_PARSE_INACTIVE)) {
def->data.spice.port = 0;
def->data.spice.tlsPort = 0;
}
if (def->info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
if (virDomainDeviceInfoParseXML(node, bootHash, def->info,
- flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT
- | VIR_DOMAIN_XML_INTERNAL_ALLOW_ROM) < 0)
+ flags | VIR_DOMAIN_DEF_PARSE_ALLOW_BOOT
+ | VIR_DOMAIN_DEF_PARSE_ALLOW_ROM) < 0)
goto error;
}
def->source.chr.data.spicevmc = VIR_DOMAIN_CHR_SPICEVMC_USBREDIR;
if (virDomainDeviceInfoParseXML(node, bootHash, &def->info,
- flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT) < 0)
+ flags | VIR_DOMAIN_DEF_PARSE_ALLOW_BOOT) < 0)
goto error;
if (def->bus == VIR_DOMAIN_REDIRDEV_BUS_USB &&
goto cleanup;
}
- flags |= VIR_DOMAIN_XML_INTERNAL_DISK_SOURCE;
+ flags |= VIR_DOMAIN_DEF_PARSE_DISK_SOURCE;
if (!(disk = virDomainDiskDefParseXML(xmlopt, node, ctxt,
NULL, def->seclabels,
def->nseclabels,
return ret;
}
+
static virDomainDefPtr
virDomainDefParseXML(xmlDocPtr xml,
xmlNodePtr root,
if (VIR_ALLOC(def) < 0)
return NULL;
- if (!(flags & VIR_DOMAIN_XML_INACTIVE))
+ if (!(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE))
if (virXPathLong("string(./@id)", ctxt, &id) < 0)
id = -1;
def->id = (int)id;
{
/* For offline output, skip elements that allow labels but have no
* label specified (possible if labelskip was ignored on input). */
- if ((flags & VIR_DOMAIN_XML_INACTIVE) && !def->label && def->relabel)
+ if ((flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE) && !def->label && def->relabel)
return;
virBufferAddLit(buf, "<seclabel");
/* Don't format backingStore to inactive XMLs until the code for
* persistent storage of backing chains is ready. */
- if (!(flags & VIR_DOMAIN_XML_INACTIVE) &&
+ if (!(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE) &&
virDomainDiskBackingStoreFormat(buf, def->src->backingStore,
def->src->backingStoreRaw, 1) < 0)
return -1;
* the new style similar to backingStore, but for back-compat on
* blockcopy files we also have to output old style attributes.
* The parser accepts either style across libvirtd upgrades. */
- if (def->mirror && !(flags & VIR_DOMAIN_XML_INACTIVE)) {
+ if (def->mirror && !(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE)) {
const char *formatStr = NULL;
if (def->mirror->format)
virStorageEncryptionFormat(buf, def->src->encryption) < 0)
return -1;
if (virDomainDeviceInfoFormat(buf, &def->info,
- flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT) < 0)
+ flags | VIR_DOMAIN_DEF_FORMAT_ALLOW_BOOT) < 0)
return -1;
virBufferAdjustIndent(buf, -2);
}
if (def->queues || def->cmd_per_lun || def->max_sectors ||
- virDomainDeviceInfoIsSet(&def->info, flags) || pcihole64) {
+ virDomainDeviceInfoNeedsFormat(&def->info, flags) || pcihole64) {
virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2);
virBufferAddLit(buf, "/>\n");
}
- if (virDomainDeviceInfoIsSet(&def->info, flags) &&
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags) &&
virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
return -1;
policy = virDomainStartupPolicyTypeToString(def->startupPolicy);
virBufferAsprintf(buf, " startupPolicy='%s'", policy);
}
- if (usbsrc->autoAddress && (flags & VIR_DOMAIN_XML_MIGRATABLE))
+ if (usbsrc->autoAddress && (flags & VIR_DOMAIN_DEF_FORMAT_MIGRATABLE))
virBufferAddLit(buf, " autoAddress='yes'");
- if (def->missing && !(flags & VIR_DOMAIN_XML_INACTIVE))
+ if (def->missing && !(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE))
virBufferAddLit(buf, " missing='yes'");
}
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("PCI address Formatting failed"));
- if ((flags & VIR_DOMAIN_XML_INTERNAL_PCI_ORIG_STATES) &&
+ if ((flags & VIR_DOMAIN_DEF_FORMAT_PCI_ORIG_STATES) &&
(def->origstates.states.pci.unbind_from_stub ||
def->origstates.states.pci.remove_slot ||
def->origstates.states.pci.reprobe)) {
*/
if (def->type == VIR_DOMAIN_NET_TYPE_NETWORK &&
def->data.network.actual &&
- !(flags & (VIR_DOMAIN_XML_INACTIVE |
- VIR_DOMAIN_XML_INTERNAL_ACTUAL_NET |
- VIR_DOMAIN_XML_MIGRATABLE)))
+ !(flags & (VIR_DOMAIN_DEF_FORMAT_INACTIVE |
+ VIR_DOMAIN_DEF_FORMAT_ACTUAL_NET |
+ VIR_DOMAIN_DEF_FORMAT_MIGRATABLE)))
publicActual = true;
if (publicActual) {
* as a subelement of <interface> so that no persistent config
* data is overwritten.
*/
- if ((flags & VIR_DOMAIN_XML_INTERNAL_ACTUAL_NET) &&
+ if ((flags & VIR_DOMAIN_DEF_FORMAT_ACTUAL_NET) &&
(virDomainActualNetDefFormat(buf, def, flags) < 0))
return -1;
break;
virBufferEscapeString(buf, "<script path='%s'/>\n",
def->script);
if (def->ifname &&
- !((flags & VIR_DOMAIN_XML_INACTIVE) &&
+ !((flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE) &&
(STRPREFIX(def->ifname, VIR_NET_GENERATED_PREFIX)))) {
/* Skip auto-generated target names for inactive config. */
virBufferEscapeString(buf, "<target dev='%s'/>\n", def->ifname);
virDomainNetInterfaceLinkStateTypeToString(def->linkstate));
}
if (virDomainDeviceInfoFormat(buf, &def->info,
- flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT
- | VIR_DOMAIN_XML_INTERNAL_ALLOW_ROM) < 0)
+ flags | VIR_DOMAIN_DEF_FORMAT_ALLOW_BOOT
+ | VIR_DOMAIN_DEF_FORMAT_ALLOW_ROM) < 0)
return -1;
virBufferAdjustIndent(buf, -2);
case VIR_DOMAIN_CHR_TYPE_PIPE:
if (def->type != VIR_DOMAIN_CHR_TYPE_PTY ||
(def->data.file.path &&
- !(flags & VIR_DOMAIN_XML_INACTIVE))) {
+ !(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE))) {
virBufferEscapeString(buf, "<source path='%s'",
def->data.file.path);
virDomainSourceDefFormatSeclabel(buf, nseclabels, seclabels, flags);
tty_compat = (def->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
def->target.port == 0 &&
def->source.type == VIR_DOMAIN_CHR_TYPE_PTY &&
- !(flags & VIR_DOMAIN_XML_INACTIVE) &&
+ !(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE) &&
def->source.data.file.path);
if (virDomainChrSourceDefFormat(buf, def, &def->source, tty_compat, flags) < 0)
return -1;
virBufferEscapeString(buf, " name='%s'", def->target.name);
if (def->state != VIR_DOMAIN_CHR_DEVICE_STATE_DEFAULT &&
- !(flags & VIR_DOMAIN_XML_INACTIVE)) {
+ !(flags & VIR_DOMAIN_DEF_PARSE_INACTIVE)) {
virBufferAsprintf(buf, " state='%s'",
virDomainChrDeviceStateTypeToString(def->state));
}
break;
}
- if (virDomainDeviceInfoIsSet(&def->info, flags)) {
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
return -1;
}
virBufferAdjustIndent(buf, 2);
switch (def->type) {
case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
- if (!virDomainDeviceInfoIsSet(&def->info, flags)) {
+ if (!virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "/>\n");
return 0;
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</backend>\n");
- if (virDomainDeviceInfoIsSet(&def->info, flags)) {
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
return -1;
}
virDomainSoundCodecDefFormat(buf, def->codecs[i]);
}
- if (virDomainDeviceInfoIsSet(&def->info, flags)) {
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
if (!children) {
virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2);
virBufferAsprintf(buf, "<memballoon model='%s'", model);
virBufferAdjustIndent(buf, 2);
- if (virDomainDeviceInfoIsSet(&def->info, flags)) {
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
virBufferAddLit(buf, ">\n");
if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
return -1;
{
virBufferAddLit(buf, "<nvram>\n");
virBufferAdjustIndent(buf, 2);
- if (virDomainDeviceInfoIsSet(&def->info, flags) &&
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags) &&
virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
return -1;
virBufferAsprintf(buf, "<watchdog model='%s' action='%s'",
model, action);
- if (virDomainDeviceInfoIsSet(&def->info, flags)) {
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2);
if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
if (!def->size &&
!def->server.enabled &&
!def->msi.enabled &&
- !virDomainDeviceInfoIsSet(&def->info, flags)) {
+ !virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
virBufferAddLit(buf, "/>\n");
return 0;
} else {
break;
}
- if (virDomainDeviceInfoIsSet(&def->info, flags)) {
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
return -1;
}
virBufferAsprintf(buf, "<input type='%s' bus='%s'",
type, bus);
- if (virDomainDeviceInfoIsSet(&def->info, flags)) {
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2);
if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
if (!def->passwd)
return;
- if (flags & VIR_DOMAIN_XML_SECURE)
+ if (flags & VIR_DOMAIN_DEF_FORMAT_SECURE)
virBufferEscapeString(buf, " passwd='%s'",
def->passwd);
{
/* If generating migratable XML, skip listen address
* dragged in from config file */
- if ((flags & VIR_DOMAIN_XML_MIGRATABLE) && def->fromConfig)
+ if ((flags & VIR_DOMAIN_DEF_FORMAT_MIGRATABLE) && def->fromConfig)
return;
virBufferAddLit(buf, "<listen");
if (def->address &&
(def->type == VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS ||
(def->type == VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK &&
- !(flags & VIR_DOMAIN_XML_INACTIVE)))) {
+ !(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE)))) {
/* address may also be set to show current status when type='network',
* but we don't want to print that if INACTIVE data is requested. */
virBufferAsprintf(buf, " address='%s'", def->address);
virBufferEscapeString(buf, " network='%s'", def->network);
}
- if (flags & VIR_DOMAIN_XML_INTERNAL_STATUS)
+ if (flags & VIR_DOMAIN_DEF_FORMAT_STATUS)
virBufferAsprintf(buf, " fromConfig='%d'", def->fromConfig);
virBufferAddLit(buf, "/>\n");
for (i = 0; i < def->nListens; i++) {
if (virDomainGraphicsListenGetType(def, i)
== VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS) {
- if (flags & VIR_DOMAIN_XML_MIGRATABLE &&
+ if (flags & VIR_DOMAIN_DEF_FORMAT_MIGRATABLE &&
def->listens[i].fromConfig)
continue;
listenAddr = virDomainGraphicsListenGetAddress(def, i);
def->data.vnc.socket);
} else {
if (def->data.vnc.port &&
- (!def->data.vnc.autoport || !(flags & VIR_DOMAIN_XML_INACTIVE)))
+ (!def->data.vnc.autoport || !(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE)))
virBufferAsprintf(buf, " port='%d'",
def->data.vnc.port);
else if (def->data.vnc.autoport)
if (virDomainGraphicsListenGetType(def, i)
== VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NONE)
continue;
- if (flags & VIR_DOMAIN_XML_MIGRATABLE &&
+ if (flags & VIR_DOMAIN_DEF_FORMAT_MIGRATABLE &&
def->listens[i].fromConfig)
continue;
if (!children) {
virBufferAddLit(buf, "<shareable/>\n");
if (virDomainDeviceInfoFormat(buf, def->info,
- flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT
- | VIR_DOMAIN_XML_INTERNAL_ALLOW_ROM) < 0)
+ flags | VIR_DOMAIN_DEF_FORMAT_ALLOW_BOOT
+ | VIR_DOMAIN_DEF_FORMAT_ALLOW_ROM) < 0)
return -1;
virBufferAdjustIndent(buf, -2);
if (virDomainChrSourceDefFormat(buf, NULL, &def->source.chr, false, flags) < 0)
return -1;
if (virDomainDeviceInfoFormat(buf, &def->info,
- flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT) < 0)
+ flags | VIR_DOMAIN_DEF_FORMAT_ALLOW_BOOT) < 0)
return -1;
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</redirdev>\n");
virBufferAsprintf(buf, "<hub type='%s'", type);
- if (virDomainDeviceInfoIsSet(&def->info, flags)) {
+ if (virDomainDeviceInfoNeedsFormat(&def->info, flags)) {
virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2);
if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
return false;
}
-/* This internal version can accept VIR_DOMAIN_XML_INTERNAL_*,
- * whereas the public version cannot. Also, it appends to an existing
- * buffer (possibly with auto-indent), rather than flattening to string.
+/* This internal version appends to an existing buffer
+ * (possibly with auto-indent), rather than flattening
+ * to string.
* Return -1 on failure. */
int
virDomainDefFormatInternal(virDomainDefPtr def,
bool blkio = false;
bool cputune = false;
- virCheckFlags(DUMPXML_FLAGS |
- VIR_DOMAIN_XML_INTERNAL_STATUS |
- VIR_DOMAIN_XML_INTERNAL_ACTUAL_NET |
- VIR_DOMAIN_XML_INTERNAL_PCI_ORIG_STATES |
- VIR_DOMAIN_XML_INTERNAL_CLOCK_ADJUST,
+ virCheckFlags(VIR_DOMAIN_DEF_FORMAT_COMMON_FLAGS |
+ VIR_DOMAIN_DEF_FORMAT_STATUS |
+ VIR_DOMAIN_DEF_FORMAT_ACTUAL_NET |
+ VIR_DOMAIN_DEF_FORMAT_PCI_ORIG_STATES |
+ VIR_DOMAIN_DEF_FORMAT_CLOCK_ADJUST,
-1);
if (!(type = virDomainVirtTypeToString(def->virtType))) {
}
if (def->id == -1)
- flags |= VIR_DOMAIN_XML_INACTIVE;
+ flags |= VIR_DOMAIN_DEF_FORMAT_INACTIVE;
virBufferAsprintf(buf, "<domain type='%s'", type);
- if (!(flags & VIR_DOMAIN_XML_INACTIVE))
+ if (!(flags & VIR_DOMAIN_DEF_FORMAT_INACTIVE))
virBufferAsprintf(buf, " id='%d'", def->id);
if (def->namespaceData && def->ns.href)
virBufferAsprintf(buf, " %s", (def->ns.href)());
}
if (virCPUDefFormatBufFull(buf, def->cpu,
- !!(flags & VIR_DOMAIN_XML_UPDATE_CPU)) < 0)
+ !!(flags & VIR_DOMAIN_DEF_FORMAT_UPDATE_CPU)) < 0)
goto error;
virBufferAsprintf(buf, "<clock offset='%s'",
virBufferAsprintf(buf, " adjustment='%lld' basis='%s'",
def->clock.data.variable.adjustment,
virDomainClockBasisTypeToString(def->clock.data.variable.basis));
- if (flags & VIR_DOMAIN_XML_INTERNAL_CLOCK_ADJUST) {
+ if (flags & VIR_DOMAIN_DEF_FORMAT_CLOCK_ADJUST) {
if (def->clock.data.variable.adjustment0)
virBufferAsprintf(buf, " adjustment0='%lld'",
def->clock.data.variable.adjustment0);
if (virDomainInputDefFormat(buf, &autoInput, flags) < 0)
goto error;
- if (!(flags & VIR_DOMAIN_XML_MIGRATABLE)) {
+ if (!(flags & VIR_DOMAIN_DEF_FORMAT_MIGRATABLE)) {
autoInput.type = VIR_DOMAIN_INPUT_TYPE_KBD;
if (virDomainInputDefFormat(buf, &autoInput, flags) < 0)
goto error;
return -1;
}
+unsigned int virDomainDefFormatConvertXMLFlags(unsigned int flags)
+{
+ unsigned int formatFlags = 0;
+
+ if (flags & VIR_DOMAIN_XML_SECURE)
+ formatFlags |= VIR_DOMAIN_DEF_FORMAT_SECURE;
+ if (flags & VIR_DOMAIN_XML_INACTIVE)
+ formatFlags |= VIR_DOMAIN_DEF_FORMAT_INACTIVE;
+ if (flags & VIR_DOMAIN_XML_UPDATE_CPU)
+ formatFlags |= VIR_DOMAIN_DEF_FORMAT_UPDATE_CPU;
+ if (flags & VIR_DOMAIN_XML_MIGRATABLE)
+ formatFlags |= VIR_DOMAIN_DEF_FORMAT_MIGRATABLE;
+
+ return formatFlags;
+}
+
+
char *
virDomainDefFormat(virDomainDefPtr def, unsigned int flags)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
- virCheckFlags(DUMPXML_FLAGS, NULL);
+ virCheckFlags(VIR_DOMAIN_DEF_FORMAT_COMMON_FLAGS, NULL);
if (virDomainDefFormatInternal(def, flags, &buf) < 0)
return NULL;
int ret = -1;
char *xml;
- if (!(xml = virDomainDefFormat(def, VIR_DOMAIN_XML_WRITE_FLAGS)))
+ if (!(xml = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_SECURE)))
goto cleanup;
if (virDomainSaveXML(configDir, def, xml))
const char *statusDir,
virDomainObjPtr obj)
{
- unsigned int flags = (VIR_DOMAIN_XML_SECURE |
- VIR_DOMAIN_XML_INTERNAL_STATUS |
- VIR_DOMAIN_XML_INTERNAL_ACTUAL_NET |
- VIR_DOMAIN_XML_INTERNAL_PCI_ORIG_STATES |
- VIR_DOMAIN_XML_INTERNAL_CLOCK_ADJUST);
+ unsigned int flags = (VIR_DOMAIN_DEF_FORMAT_SECURE |
+ VIR_DOMAIN_DEF_FORMAT_STATUS |
+ VIR_DOMAIN_DEF_FORMAT_ACTUAL_NET |
+ VIR_DOMAIN_DEF_FORMAT_PCI_ORIG_STATES |
+ VIR_DOMAIN_DEF_FORMAT_CLOCK_ADJUST);
int ret = -1;
char *xml;
goto error;
if (!(def = virDomainDefParseFile(configFile, caps, xmlopt,
expectedVirtTypes,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto error;
if ((autostartLink = virDomainConfigFile(autostartDir, name)) == NULL)
goto error;
if (!(obj = virDomainObjParseFile(statusFile, caps, xmlopt, expectedVirtTypes,
- VIR_DOMAIN_XML_INTERNAL_STATUS |
- VIR_DOMAIN_XML_INTERNAL_ACTUAL_NET |
- VIR_DOMAIN_XML_INTERNAL_PCI_ORIG_STATES |
- VIR_DOMAIN_XML_INTERNAL_CLOCK_ADJUST)))
+ VIR_DOMAIN_DEF_PARSE_STATUS |
+ VIR_DOMAIN_DEF_PARSE_ACTUAL_NET |
+ VIR_DOMAIN_DEF_PARSE_PCI_ORIG_STATES |
+ VIR_DOMAIN_DEF_PARSE_CLOCK_ADJUST)))
goto error;
virUUIDFormat(obj->def->uuid, uuidstr);
{
char *xml;
virDomainDefPtr ret;
- unsigned int write_flags = VIR_DOMAIN_XML_WRITE_FLAGS;
- unsigned int read_flags = VIR_DOMAIN_XML_READ_FLAGS;
+ unsigned int format_flags = VIR_DOMAIN_DEF_FORMAT_SECURE;
+ unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
if (migratable)
- write_flags |= VIR_DOMAIN_XML_INACTIVE | VIR_DOMAIN_XML_MIGRATABLE;
+ format_flags |= VIR_DOMAIN_DEF_FORMAT_INACTIVE | VIR_DOMAIN_DEF_FORMAT_MIGRATABLE;
/* Easiest to clone via a round-trip through XML. */
- if (!(xml = virDomainDefFormat(src, write_flags)))
+ if (!(xml = virDomainDefFormat(src, format_flags)))
return NULL;
- ret = virDomainDefParseString(xml, caps, xmlopt, -1, read_flags);
+ ret = virDomainDefParseString(xml, caps, xmlopt, -1, parse_flags);
VIR_FREE(xml);
return ret;
* @src: source to be copied
*
* virDomainDeviceDefCopy does a deep copy of only the parts of a
- * DeviceDef that are valid when just the flag VIR_DOMAIN_XML_INACTIVE is
+ * DeviceDef that are valid when just the flag VIR_DOMAIN_DEF_PARSE_INACTIVE is
* set. This means that any part of the device xml that is conditionally
* parsed/formatted based on some other flag being set (or on the INACTIVE
* flag being reset) *will not* be copied to the destination. Caveat emptor.
{
virDomainDeviceDefPtr ret = NULL;
virBuffer buf = VIR_BUFFER_INITIALIZER;
- int flags = VIR_DOMAIN_XML_INACTIVE | VIR_DOMAIN_XML_SECURE;
+ int flags = VIR_DOMAIN_DEF_FORMAT_INACTIVE | VIR_DOMAIN_DEF_FORMAT_SECURE;
char *xmlStr = NULL;
int rc = -1;
goto cleanup;
xmlStr = virBufferContentAndReset(&buf);
- ret = virDomainDeviceDefParse(xmlStr, def, caps, xmlopt, flags);
+ ret = virDomainDeviceDefParse(xmlStr, def, caps, xmlopt,
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
cleanup:
VIR_FREE(xmlStr);
void virDomainObjListRemoveLocked(virDomainObjListPtr doms,
virDomainObjPtr dom);
+typedef enum {
+ /* parse internal domain status information */
+ VIR_DOMAIN_DEF_PARSE_STATUS = 1 << 0,
+ VIR_DOMAIN_DEF_PARSE_INACTIVE = 1 << 1,
+ /* parse <actual> element */
+ VIR_DOMAIN_DEF_PARSE_ACTUAL_NET = 1 << 2,
+ /* parse original states of host PCI device */
+ VIR_DOMAIN_DEF_PARSE_PCI_ORIG_STATES = 1 << 3,
+ VIR_DOMAIN_DEF_PARSE_ALLOW_ROM = 1 << 4,
+ VIR_DOMAIN_DEF_PARSE_ALLOW_BOOT = 1 << 5,
+ VIR_DOMAIN_DEF_PARSE_CLOCK_ADJUST = 1 << 6,
+ /* parse only source half of <disk> */
+ VIR_DOMAIN_DEF_PARSE_DISK_SOURCE = 1 << 7,
+} virDomainDefParseFlags;
+
+typedef enum {
+ VIR_DOMAIN_DEF_FORMAT_SECURE = 1 << 0,
+ VIR_DOMAIN_DEF_FORMAT_INACTIVE = 1 << 1,
+ VIR_DOMAIN_DEF_FORMAT_UPDATE_CPU = 1 << 2,
+ VIR_DOMAIN_DEF_FORMAT_MIGRATABLE = 1 << 3,
+ /* format internal domain status information */
+ VIR_DOMAIN_DEF_FORMAT_STATUS = 1 << 4,
+ /* format <actual> element */
+ VIR_DOMAIN_DEF_FORMAT_ACTUAL_NET = 1 << 5,
+ /* format original states of host PCI device */
+ VIR_DOMAIN_DEF_FORMAT_PCI_ORIG_STATES = 1 << 6,
+ VIR_DOMAIN_DEF_FORMAT_ALLOW_ROM = 1 << 7,
+ VIR_DOMAIN_DEF_FORMAT_ALLOW_BOOT = 1 << 8,
+ VIR_DOMAIN_DEF_FORMAT_CLOCK_ADJUST = 1 << 9,
+} virDomainDefFormatFlags;
+
virDomainDeviceDefPtr virDomainDeviceDefParse(const char *xmlStr,
const virDomainDef *def,
virCapsPtr caps,
int virDomainDefAddImplicitControllers(virDomainDefPtr def);
+unsigned int virDomainDefFormatConvertXMLFlags(unsigned int flags);
+
char *virDomainDefFormat(virDomainDefPtr def,
unsigned int flags);
int virDomainDefFormatInternal(virDomainDefPtr def,
def->dom = virDomainDefParseNode(ctxt->node->doc, domainNode,
caps, xmlopt,
expectedVirtTypes,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!def->dom)
goto cleanup;
} else {
virBuffer buf = VIR_BUFFER_INITIALIZER;
size_t i;
- virCheckFlags(VIR_DOMAIN_XML_SECURE |
- VIR_DOMAIN_XML_UPDATE_CPU, NULL);
+ virCheckFlags(VIR_DOMAIN_DEF_FORMAT_SECURE |
+ VIR_DOMAIN_DEF_FORMAT_UPDATE_CPU, NULL);
- flags |= VIR_DOMAIN_XML_INACTIVE;
+ flags |= VIR_DOMAIN_DEF_FORMAT_INACTIVE;
virBufferAddLit(&buf, "<domainsnapshot>\n");
virBufferAdjustIndent(&buf, 2);
if (powerState != esxVI_VirtualMachinePowerState_PoweredOff)
def->id = id;
- xml = virDomainDefFormat(def, flags);
+ xml = virDomainDefFormat(def,
+ virDomainDefFormatConvertXMLFlags(flags));
}
cleanup:
def = virVMXParseConfig(&ctx, priv->xmlopt, nativeConfig);
if (def)
- xml = virDomainDefFormat(def, VIR_DOMAIN_XML_INACTIVE);
+ xml = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_INACTIVE);
virDomainDefFree(def);
def = virDomainDefParseString(domainXml, priv->caps, priv->xmlopt,
1 << VIR_DOMAIN_VIRT_VMWARE,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!def)
return NULL;
/* Parse domain XML */
def = virDomainDefParseString(xml, priv->caps, priv->xmlopt,
1 << VIR_DOMAIN_VIRT_VMWARE,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!def)
return NULL;
virUUIDFormat(snapshot->domain->uuid, uuid_string);
- xml = virDomainSnapshotDefFormat(uuid_string, &def, flags, 0);
+ xml = virDomainSnapshotDefFormat(uuid_string, &def,
+ virDomainDefFormatConvertXMLFlags(flags),
+ 0);
cleanup:
esxVI_VirtualMachineSnapshotTree_Free(&rootSnapshotList);
/* FIXME: devices section is totally missing */
- xml = virDomainDefFormat(def, flags);
+ xml = virDomainDefFormat(def,
+ virDomainDefFormatConvertXMLFlags(flags));
cleanup:
virDomainDefFree(def);
virDomainDefCopy;
virDomainDefFindDevice;
virDomainDefFormat;
+virDomainDefFormatConvertXMLFlags;
virDomainDefFormatInternal;
virDomainDefFree;
virDomainDefGetDefaultEmulator;
if (!(def = virDomainDefParseString(xml, cfg->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto error;
VIR_FREE(xml);
if (!(def = virDomainDefParseString(xml, cfg->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainCreateXMLEnsureACL(conn, def) < 0)
if (virDomainGetXMLDescEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- ret = virDomainDefFormat(vm->def, flags);
+ ret = virDomainDefFormat(vm->def,
+ virDomainDefFormatConvertXMLFlags(flags));
cleanup:
if (vm)
goto cleanup;
}
- xml = virDomainDefFormat(def, VIR_DOMAIN_XML_INACTIVE);
+ xml = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_INACTIVE);
cleanup:
virDomainDefFree(def);
if (!(def = virDomainDefParseString(domainXml,
cfg->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (!(conf = xenFormatXM(conn, def, cfg->verInfo->xen_version_major)))
if (!(def = virDomainDefParseString(xml, cfg->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainDefineXMLFlagsEnsureACL(conn, def) < 0)
if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
if (!(dev = virDomainDeviceDefParse(xml, vm->def,
cfg->caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto endjob;
/* Make a copy for updated domain. */
virDomainDeviceDefFree(dev);
if (!(dev = virDomainDeviceDefParse(xml, vm->def,
cfg->caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto endjob;
if (libxlDomainAttachDeviceLive(driver, priv, vm, dev) < 0)
if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
if (!(dev = virDomainDeviceDefParse(xml, vm->def,
cfg->caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto endjob;
/* Make a copy for updated domain. */
virDomainDeviceDefFree(dev);
if (!(dev = virDomainDeviceDefParse(xml, vm->def,
cfg->caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto endjob;
if (libxlDomainDetachDeviceLive(driver, priv, vm, dev) < 0)
if (flags & VIR_DOMAIN_DEVICE_MODIFY_CONFIG) {
if (!(dev = virDomainDeviceDefParse(xml, vm->def,
cfg->caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
/* Make a copy for updated domain. */
virDomainDeviceDefFree(dev);
if (!(dev = virDomainDeviceDefParse(xml, vm->def,
cfg->caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if ((ret = libxlDomainUpdateDeviceLive(priv, vm, dev)) < 0)
if (!(tmpdef = virDomainDefParseString(xmlin, cfg->caps,
driver->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto endjob;
if (!libxlDomainDefCheckABIStability(driver, vm->def, tmpdef))
if (!libxlDomainMigrationIsAllowed(def))
goto endjob;
- xml = virDomainDefFormat(def, VIR_DOMAIN_XML_SECURE);
+ xml = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_SECURE);
endjob:
if (!libxlDomainObjEndJob(driver, vm))
if (!(def = virDomainDefParseString(dom_xml, cfg->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (dname) {
if (!(def = virDomainDefParseString(xml, caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_LXC,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainDefineXMLFlagsEnsureACL(conn, def) < 0)
ret = virDomainDefFormat((flags & VIR_DOMAIN_XML_INACTIVE) &&
vm->newDef ? vm->newDef : vm->def,
- flags);
+ virDomainDefFormatConvertXMLFlags(flags));
cleanup:
if (vm)
if (!(def = virDomainDefParseString(xml, caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_LXC,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainCreateXMLWithFilesEnsureACL(conn, def) < 0)
dev = dev_copy = virDomainDeviceDefParse(xml, vm->def,
caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (dev == NULL)
goto cleanup;
dev = dev_copy = virDomainDeviceDefParse(xml, vm->def,
caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (dev == NULL)
goto cleanup;
dev = dev_copy = virDomainDeviceDefParse(xml, vm->def,
caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (dev == NULL)
goto cleanup;
goto cleanup;
}
- ret = virDomainDefFormat(vm->def, flags);
+ ret = virDomainDefFormat(vm->def,
+ virDomainDefFormatConvertXMLFlags(flags));
cleanup:
if (vm)
openvzDriverLock(driver);
if ((vmdef = virDomainDefParseString(xml, driver->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_OPENVZ,
- VIR_DOMAIN_XML_INACTIVE)) == NULL)
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)) == NULL)
goto cleanup;
vm = virDomainObjListFindByName(driver->domains, vmdef->name);
openvzDriverLock(driver);
if ((vmdef = virDomainDefParseString(xml, driver->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_OPENVZ,
- VIR_DOMAIN_XML_INACTIVE)) == NULL)
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)) == NULL)
goto cleanup;
vm = virDomainObjListFindByName(driver->domains, vmdef->name);
goto cleanup;
dev = virDomainDeviceDefParse(xml, vmdef, driver->caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!dev)
goto cleanup;
goto cleanup;
}
- xml = virDomainDefFormat(vm->def, VIR_DOMAIN_XML_SECURE);
+ xml = virDomainDefFormat(vm->def, VIR_DOMAIN_DEF_FORMAT_SECURE);
cleanup:
if (vm)
if (!(def = virDomainDefParseString(dom_xml, driver->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_OPENVZ,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto error;
if (!(vm = virDomainObjListAdd(driver->domains, def,
parallelsDriverLock(privconn);
if ((def = virDomainDefParseString(xml, privconn->caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_PARALLELS,
- VIR_DOMAIN_XML_INACTIVE)) == NULL)
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)) == NULL)
goto cleanup;
olddom = virDomainObjListFindByUUID(privconn->domains, def->uuid);
goto cleanup;
dev = virDomainDeviceDefParse(xml, def, phyp_driver->caps, NULL,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!dev)
goto cleanup;
goto err;
}
- return virDomainDefFormat(&def, flags);
+ return virDomainDefFormat(&def,
+ virDomainDefFormatConvertXMLFlags(flags));
err:
return NULL;
if (!(ret = virDomainDefParseString(xml, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
cleanup:
}
- ret = virDomainDefFormatInternal(def, flags, buf);
+ ret = virDomainDefFormatInternal(def,
+ virDomainDefFormatConvertXMLFlags(flags),
+ buf);
cleanup:
def->cpu = def_cpu;
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(vm->def->uuid, uuidstr);
- newxml = virDomainSnapshotDefFormat(uuidstr, snapshot->def,
- QEMU_DOMAIN_FORMAT_LIVE_FLAGS, 1);
+ newxml = virDomainSnapshotDefFormat(
+ uuidstr, snapshot->def,
+ virDomainDefFormatConvertXMLFlags(QEMU_DOMAIN_FORMAT_LIVE_FLAGS),
+ 1);
if (newxml == NULL)
return -1;
if (!(def = virDomainDefParseString(xml, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainCreateXMLEnsureACL(conn, def) < 0)
if (!(def = virDomainDefParseString(xmlin, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE))) {
+ VIR_DOMAIN_DEF_PARSE_INACTIVE))) {
goto endjob;
}
if (!qemuDomainDefCheckABIStability(driver, vm->def, def)) {
if (!(newdef = virDomainDefParseString(newxml, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (!(newdef_migr = qemuDomainDefCopy(driver,
/* Create a domain from this XML */
if (!(def = virDomainDefParseString(xml, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto error;
if (xmlout)
def = virDomainDefParseString(xmlData, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!def)
goto cleanup;
if (!(def = virDomainDefParseString(xml, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainDefineXMLFlagsEnsureACL(conn, def) < 0)
virDomainDefPtr vmdef = NULL;
virDomainDeviceDefPtr dev = NULL, dev_copy = NULL;
int ret = -1;
- unsigned int affect, parse_flags = VIR_DOMAIN_XML_INACTIVE;
+ unsigned int affect, parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
virQEMUCapsPtr qemuCaps = NULL;
qemuDomainObjPrivatePtr priv;
virQEMUDriverConfigPtr cfg = NULL;
dev = dev_copy = virDomainDeviceDefParse(xml, vm->def,
caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (dev == NULL)
goto endjob;
if ((flags & VIR_DOMAIN_AFFECT_CONFIG) &&
!(flags & VIR_DOMAIN_AFFECT_LIVE))
- parse_flags |= VIR_DOMAIN_XML_INACTIVE;
+ parse_flags |= VIR_DOMAIN_DEF_PARSE_INACTIVE;
dev = dev_copy = virDomainDeviceDefParse(xml, vm->def,
caps, driver->xmlopt,
if (!(xml = qemuDomainDefFormatLive(driver, vm->def, true, true)) ||
!(def->dom = virDomainDefParseString(xml, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto endjob;
if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY) {
virUUIDFormat(snapshot->domain->uuid, uuidstr);
- xml = virDomainSnapshotDefFormat(uuidstr, snap->def, flags, 0);
+ xml = virDomainSnapshotDefFormat(uuidstr, snap->def,
+ virDomainDefFormatConvertXMLFlags(flags),
+ 0);
cleanup:
qemuDomObjEndAPI(&vm);
}
if (!(dest = virDomainDiskDefSourceParse(destxml, vm->def, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
ret = qemuDomainBlockCopyCommon(vm, dom->conn, disk, dest, bandwidth,
}
mig->persistent = virDomainDefParseNode(doc, nodes[0],
caps, driver->xmlopt,
- -1, VIR_DOMAIN_XML_INACTIVE);
+ -1, VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!mig->persistent) {
/* virDomainDefParseNode already reported
* an error for us */
if (xmlin) {
if (!(def = virDomainDefParseString(xmlin, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (!qemuDomainDefCheckABIStability(driver, vm->def, def))
VIR_DEBUG("Using hook-filtered domain XML: %s", xmlout);
newdef = virDomainDefParseString(xmlout, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!newdef)
goto cleanup;
if (!(def = virDomainDefParseString(dom_xml, caps, driver->xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (dname) {
const char *probe = virSecurityManagerGetAllowDiskFormatProbing(mgr)
? "1" : "0";
- xml = virDomainDefFormat(def, VIR_DOMAIN_XML_SECURE);
+ xml = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_SECURE);
if (!xml)
goto cleanup;
ctl->def = virDomainDefParseString(xmlStr,
ctl->caps, ctl->xmlopt,
- -1, VIR_DOMAIN_XML_INACTIVE);
+ -1,
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (ctl->def == NULL) {
vah_error(ctl, 0, _("could not parse XML"));
goto exit;
privconn->caps,
privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_TEST,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto error;
if (testDomainGenerateIfnames(domdef) < 0)
def = virDomainDefParseNode(ctxt->doc, node,
privconn->caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_TEST,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!def)
goto error;
testDriverLock(privconn);
if ((def = virDomainDefParseString(xml, privconn->caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_TEST,
- VIR_DOMAIN_XML_INACTIVE)) == NULL)
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)) == NULL)
goto cleanup;
if (testDomainGenerateIfnames(def) < 0)
}
xml = virDomainDefFormat(privdom->def,
- VIR_DOMAIN_XML_SECURE);
+ VIR_DOMAIN_DEF_FORMAT_SECURE);
if (xml == NULL) {
virReportSystemError(errno,
def = virDomainDefParseString(xml, privconn->caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_TEST,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!def)
goto cleanup;
privdom->newDef ? privdom->newDef : privdom->def;
ret = virDomainDefFormat(def,
- flags);
+ virDomainDefFormatConvertXMLFlags(flags));
cleanup:
if (privdom)
testDriverLock(privconn);
if ((def = virDomainDefParseString(xml, privconn->caps, privconn->xmlopt,
1 << VIR_DOMAIN_VIRT_TEST,
- VIR_DOMAIN_XML_INACTIVE)) == NULL)
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)) == NULL)
goto cleanup;
if (testDomainGenerateIfnames(def) < 0)
virUUIDFormat(snapshot->domain->uuid, uuidstr);
- xml = virDomainSnapshotDefFormat(uuidstr, snap->def, flags, 0);
+ xml = virDomainSnapshotDefFormat(uuidstr, snap->def,
+ virDomainDefFormatConvertXMLFlags(flags),
+ 0);
cleanup:
if (vm)
umlDriverLock(driver);
if (!(def = virDomainDefParseString(xml, driver->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_UML,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainCreateXMLEnsureACL(conn, def) < 0)
ret = virDomainDefFormat((flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef ?
vm->newDef : vm->def,
- flags);
+ virDomainDefFormatConvertXMLFlags(flags));
cleanup:
if (vm)
umlDriverLock(driver);
if (!(def = virDomainDefParseString(xml, driver->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_UML,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainDefineXMLFlagsEnsureACL(conn, def) < 0)
}
dev = virDomainDeviceDefParse(xml, vm->def, driver->caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (dev == NULL)
goto cleanup;
}
dev = virDomainDeviceDefParse(xml, vm->def, driver->caps, driver->xmlopt,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (dev == NULL)
goto cleanup;
VBOX_IID_INITIALIZE(&mchiid);
if (!(def = virDomainDefParseString(xml, data->caps, data->xmlopt,
1 << VIR_DOMAIN_VIRT_VBOX,
- VIR_DOMAIN_XML_INACTIVE))) {
+ VIR_DOMAIN_DEF_PARSE_INACTIVE))) {
goto cleanup;
}
/* dump USB devices/filters if active */
vboxHostDeviceGetXMLDesc(data, def, machine);
- ret = virDomainDefFormat(def, flags);
+ ret = virDomainDefFormat(def, virDomainDefFormatConvertXMLFlags(flags));
cleanup:
VBOX_RELEASE(machine);
goto cleanup;
dev = virDomainDeviceDefParse(xml, def, data->caps, data->xmlopt,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (dev == NULL)
goto cleanup;
goto cleanup;
dev = virDomainDeviceDefParse(xml, def, data->caps, data->xmlopt,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (dev == NULL)
goto cleanup;
VIR_FREE(currentSnapshotXmlFilePath);
if (virAsprintf(¤tSnapshotXmlFilePath, "%s%s.xml", machineLocationPath, snapshotMachineDesc->currentSnapshot) < 0)
goto cleanup;
- char *snapshotContent = virDomainSnapshotDefFormat(NULL, def, VIR_DOMAIN_XML_SECURE, 0);
+ char *snapshotContent = virDomainSnapshotDefFormat(NULL, def, VIR_DOMAIN_DEF_FORMAT_SECURE, 0);
if (snapshotContent == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Unable to get snapshot content"));
virUUIDFormat(dom->uuid, uuidstr);
memcpy(def->dom->uuid, dom->uuid, VIR_UUID_BUFLEN);
- ret = virDomainSnapshotDefFormat(uuidstr, def, flags, 0);
+ ret = virDomainSnapshotDefFormat(uuidstr, def,
+ virDomainDefFormatConvertXMLFlags(flags),
+ 0);
cleanup:
virDomainSnapshotDefFree(def);
vmwareDriverLock(driver);
if ((vmdef = virDomainDefParseString(xml, driver->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_VMWARE,
- VIR_DOMAIN_XML_INACTIVE)) == NULL)
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)) == NULL)
goto cleanup;
/* generate vmx file */
if ((vmdef = virDomainDefParseString(xml, driver->caps, driver->xmlopt,
1 << VIR_DOMAIN_VIRT_VMWARE,
- VIR_DOMAIN_XML_INACTIVE)) == NULL)
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)) == NULL)
goto cleanup;
/* generate vmx file */
goto cleanup;
}
- ret = virDomainDefFormat(vm->def, flags);
+ ret = virDomainDefFormat(vm->def,
+ virDomainDefFormatConvertXMLFlags(flags));
cleanup:
if (vm)
def = virVMXParseConfig(&ctx, driver->xmlopt, nativeConfig);
if (def != NULL)
- xml = virDomainDefFormat(def, VIR_DOMAIN_XML_INACTIVE);
+ xml = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_INACTIVE);
virDomainDefFree(def);
if (!(def = virDomainDefParseString(xml, priv->caps, priv->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainCreateXMLEnsureACL(conn, def) < 0)
}
if (def)
- ret = virDomainDefFormat(def, flags);
+ ret = virDomainDefFormat(def,
+ virDomainDefFormatConvertXMLFlags(flags));
cleanup:
virDomainDefFree(def);
if (!(def = virDomainDefParseString(xmlData, priv->caps, priv->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (STREQ(format, XEN_CONFIG_FORMAT_XM)) {
if (!(def = virDomainDefParseString(xml, priv->caps, priv->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainDefineXMLFlagsEnsureACL(conn, def) < 0)
goto cleanup;
if (!(dev = virDomainDeviceDefParse(xml, def, priv->caps, priv->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
goto cleanup;
if (!(dev = virDomainDeviceDefParse(xml, def, priv->caps, priv->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
goto cleanup;
if (!(dev = virDomainDeviceDefParse(xml, def, priv->caps, priv->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (virDomainXMLDevID(conn, minidef, dev, class, ref, sizeof(ref)))
if (!(dev = virDomainDeviceDefParse(xml, entry->def,
priv->caps,
priv->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
switch (dev->type) {
if (!(dev = virDomainDeviceDefParse(xml, entry->def,
priv->caps,
priv->xmlopt,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
switch (dev->type) {
virDomainDefPtr defPtr = virDomainDefParseString(xmlDesc,
priv->caps, priv->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
createVMRecordFromXml(conn, defPtr, &record, &vm);
virDomainDefFree(defPtr);
if (record) {
virDomainDefPtr defPtr = virDomainDefParseString(xml,
priv->caps, priv->xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (!defPtr)
return NULL;
if (!(vmdef = virDomainDefParseFile(xml, driver.caps, driver.xmlopt,
1 << VIR_DOMAIN_VIRT_BHYVE,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto out;
vm.def = vmdef;
if (!(def = virDomainDefParseString(inXmlData, driver.caps, driver.xmlopt,
1 << VIR_DOMAIN_VIRT_BHYVE,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto fail;
- if (!(actual = virDomainDefFormat(def, VIR_DOMAIN_XML_INACTIVE)))
+ if (!(actual = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_INACTIVE)))
goto fail;
if (STRNEQ(outXmlData, actual)) {
goto cleanup;
if (!(actual = virDomainSnapshotDefFormat(uuid, def,
- VIR_DOMAIN_XML_SECURE,
+ VIR_DOMAIN_DEF_FORMAT_SECURE,
internal)))
goto cleanup;
if (!(def = virDomainDefParseString(inXmlData, caps, xmlopt,
1 << VIR_DOMAIN_VIRT_LXC,
- live ? 0 : VIR_DOMAIN_XML_INACTIVE)))
+ live ? 0 : VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto fail;
if (!virDomainDefCheckABIStability(def, def)) {
goto fail;
}
- if (!(actual = virDomainDefFormat(def, VIR_DOMAIN_XML_SECURE)))
+ if (!(actual = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_SECURE)))
goto fail;
if (STRNEQ(outXmlData, actual)) {
goto cleanup;
}
- actual = virDomainDefFormat(def, VIR_DOMAIN_XML_INACTIVE);
+ actual = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_INACTIVE);
if (actual == NULL) {
err = virGetLastError();
if (!(def = virDomainDefParseString(domain_xml, caps, xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
driver.caps,
driver.xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
priv = (*vm)->privateData;
char *actual;
int ret;
- actual = virDomainDefFormat(vm->def, VIR_DOMAIN_XML_SECURE);
+ actual = virDomainDefFormat(vm->def, VIR_DOMAIN_DEF_FORMAT_SECURE);
if (!actual)
return -1;
}
if (test->action == ATTACH)
- device_parse_flags = VIR_DOMAIN_XML_INACTIVE;
+ device_parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
if (!(dev = virDomainDeviceDefParse(device_xml, vm->def,
caps, driver.xmlopt,
if (!(vmdef = virDomainDefParseFile(xml, driver.caps, driver.xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE))) {
+ VIR_DOMAIN_DEF_PARSE_INACTIVE))) {
if (!virtTestOOMActive() &&
(flags & FLAG_EXPECT_PARSE_ERROR))
goto ok;
char *actual = NULL;
int ret = -1;
virDomainDefPtr def = NULL;
- unsigned int flags = live ? 0 : VIR_DOMAIN_XML_INACTIVE;
+ unsigned int parse_flags = live ? 0 : VIR_DOMAIN_DEF_PARSE_INACTIVE;
+ unsigned int format_flags = VIR_DOMAIN_DEF_FORMAT_SECURE;
+ if (!live)
+ format_flags |= VIR_DOMAIN_DEF_FORMAT_INACTIVE;
if (virtTestLoadFile(inxml, &inXmlData) < 0)
goto fail;
goto fail;
if (!(def = virDomainDefParseString(inXmlData, driver.caps, driver.xmlopt,
- QEMU_EXPECTED_VIRT_TYPES, flags)))
+ QEMU_EXPECTED_VIRT_TYPES, parse_flags)))
goto fail;
if (!virDomainDefCheckABIStability(def, def)) {
goto fail;
}
- if (!(actual = virDomainDefFormat(def, VIR_DOMAIN_XML_SECURE | flags)))
+ if (!(actual = virDomainDefFormat(def, format_flags)))
goto fail;
if (STRNEQ(outXmlData, actual)) {
if (!(vmdef = virDomainDefParseFile(xml, driver.caps, driver.xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto fail;
if (!virDomainDefCheckABIStability(vmdef, vmdef)) {
goto cleanup;
}
- if (!(formatted = virDomainDefFormat(def, VIR_DOMAIN_XML_SECURE)))
+ if (!(formatted = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_SECURE)))
goto cleanup;
if (STRNEQ(xmlData, formatted)) {
if (!(def = virDomainDefParseString(xmlData, caps, xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto fail;
if (!virDomainDefCheckABIStability(def, def)) {
if (!(def = xenParseXM(conf, priv.xendConfigVersion, priv.caps)))
goto fail;
- if (!(gotxml = virDomainDefFormat(def, VIR_DOMAIN_XML_SECURE)))
+ if (!(gotxml = virDomainDefFormat(def, VIR_DOMAIN_DEF_FORMAT_SECURE)))
goto fail;
if (STRNEQ(xmlData, gotxml)) {
if (!(def = virDomainDefParseString(xmlData, caps, xmlopt,
1 << VIR_DOMAIN_VIRT_XEN,
- VIR_DOMAIN_XML_INACTIVE)))
+ VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto fail;
if (!virDomainDefCheckABIStability(def, def)) {
def = virDomainDefParseString(xmlData, caps, xmlopt,
1 << VIR_DOMAIN_VIRT_VMWARE,
- VIR_DOMAIN_XML_INACTIVE);
+ VIR_DOMAIN_DEF_PARSE_INACTIVE);
if (def == NULL)
goto failure;
projects / thirdparty / libvirt.git / commitdiff
