The virCaps structure gathered a ton of irrelevant data over time that.
The original reason is that it was propagated to the XML parser
functions.
This patch aims to create a new data structure virDomainXMLConf that
will contain immutable data that are used by the XML parser. This will
allow two things we need:
1) Get rid of the stuff from virCaps
2) Allow us to add callbacks to check and add driver specific stuff
after domain XML is parsed.
This first attempt removes pointers to private data allocation functions
to this new structure and update all callers and function that require
them.
lxc/lxc_conf.c lxc/lxc_conf.h \
lxc/lxc_container.c lxc/lxc_container.h \
lxc/lxc_cgroup.c lxc/lxc_cgroup.h \
+ lxc/lxc_domain.c lxc/lxc_domain.h \
lxc/lxc_fuse.c lxc/lxc_fuse.h \
lxc/lxc_controller.c
size_t nguests;
size_t nguests_max;
virCapsGuestPtr *guests;
+
+ /* Move to virDomainXMLConf later */
unsigned char macPrefix[VIR_MAC_PREFIX_BUFLEN];
unsigned int emulatorRequired : 1;
const char *defaultDiskDriverName;
int defaultDiskDriverType; /* enum virStorageFileFormat */
int (*defaultConsoleTargetType)(const char *ostype, virArch guestarch);
- void *(*privateDataAllocFunc)(void);
- void (*privateDataFreeFunc)(void *);
- int (*privateDataXMLFormat)(virBufferPtr, void *);
- int (*privateDataXMLParse)(xmlXPathContextPtr, void *);
bool hasWideScsiBus;
const char *defaultInitPath;
-
- virDomainXMLNamespace ns;
};
virHashTable *objs;
};
+
+/* This structure holds various callbacks and data needed
+ * while parsing and creating domain XMLs */
+struct _virDomainXMLConf {
+ virObject parent;
+
+ /* domain private data management callbacks */
+ virDomainXMLPrivateDataCallbacks privateData;
+
+ /* XML namespace callbacks */
+ virDomainXMLNamespace ns;
+ };
+
+
/* Private flags used internally by virDomainSaveStatus and
* virDomainLoadStatus. */
typedef enum {
static virClassPtr virDomainObjClass;
static virClassPtr virDomainObjListClass;
+static virClassPtr virDomainXMLConfClass;
static void virDomainObjDispose(void *obj);
static void virDomainObjListDispose(void *obj);
virDomainObjListDispose)))
return -1;
+ if (!(virDomainXMLConfClass = virClassNew(virClassForObject(),
+ "virDomainXMLConf",
+ sizeof(virDomainXMLConf),
+ NULL)))
+ return -1;
+
return 0;
}
VIR_ONCE_GLOBAL_INIT(virDomainObj)
+
+/**
+ * virDomainXMLConfNew:
+ *
+ * Allocate a new domain XML configuration
+ */
+virDomainXMLConfPtr
+virDomainXMLConfNew(virDomainXMLPrivateDataCallbacksPtr priv,
+ virDomainXMLNamespacePtr xmlns)
+{
+ virDomainXMLConfPtr xmlconf;
+
+ if (virDomainObjInitialize() < 0)
+ return NULL;
+
+ if (!(xmlconf = virObjectNew(virDomainXMLConfClass)))
+ return NULL;
+
+ if (priv)
+ xmlconf->privateData = *priv;
+
+ if (xmlns)
+ xmlconf->ns = *xmlns;
+
+ return xmlconf;
+}
+
+/**
+ * virDomainXMLConfGetNamespace:
+ *
+ * @xmlconf: XML parser configuration object
+ *
+ * Returns a pointer to the stored namespace structure.
+ * The lifetime of the pointer is equal to @xmlconf;
+ */
+virDomainXMLNamespacePtr
+virDomainXMLConfGetNamespace(virDomainXMLConfPtr xmlconf)
+{
+ return &xmlconf->ns;
+}
+
+
void
virBlkioDeviceWeightArrayClear(virBlkioDeviceWeightPtr deviceWeights,
int ndevices)
virDomainSnapshotObjListFree(dom->snapshots);
}
-
-virDomainObjPtr virDomainObjNew(virCapsPtr caps)
+virDomainObjPtr
+virDomainObjNew(virDomainXMLConfPtr xmlconf)
{
virDomainObjPtr domain;
if (!(domain = virObjectLockableNew(virDomainObjClass)))
return NULL;
- if (caps &&
- caps->privateDataAllocFunc) {
- if (!(domain->privateData = (caps->privateDataAllocFunc)())) {
+ if (xmlconf->privateData.alloc) {
+ if (!(domain->privateData = (xmlconf->privateData.alloc)())) {
virReportOOMError();
goto error;
}
- domain->privateDataFreeFunc = caps->privateDataFreeFunc;
+ domain->privateDataFreeFunc = xmlconf->privateData.free;
}
if (!(domain->snapshots = virDomainSnapshotObjListNew()))
*/
static virDomainObjPtr
virDomainObjListAddLocked(virDomainObjListPtr doms,
- virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const virDomainDefPtr def,
unsigned int flags,
virDomainDefPtr *oldDef)
goto error;
}
- if (!(vm = virDomainObjNew(caps)))
+ if (!(vm = virDomainObjNew(xmlconf)))
goto cleanup;
vm->def = def;
virDomainObjPtr virDomainObjListAdd(virDomainObjListPtr doms,
- virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const virDomainDefPtr def,
unsigned int flags,
virDomainDefPtr *oldDef)
virDomainObjPtr ret;
virObjectLock(doms);
- ret = virDomainObjListAddLocked(doms, caps, def, flags, oldDef);
+ ret = virDomainObjListAddLocked(doms, xmlconf, def, flags, oldDef);
virObjectUnlock(doms);
return ret;
}
*/
int
virDomainObjSetDefTransient(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
virDomainObjPtr domain,
bool live)
{
if (domain->newDef)
return 0;
- if (!(domain->newDef = virDomainDefCopy(caps, domain->def, false)))
+ if (!(domain->newDef = virDomainDefCopy(caps, xmlconf, domain->def, false)))
goto out;
ret = 0;
*/
virDomainDefPtr
virDomainObjGetPersistentDef(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
virDomainObjPtr domain)
{
- if (virDomainObjSetDefTransient(caps, domain, false) < 0)
+ if (virDomainObjSetDefTransient(caps, xmlconf, domain, false) < 0)
return NULL;
if (domain->newDef)
*/
int
virDomainLiveConfigHelperMethod(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
virDomainObjPtr dom,
unsigned int *flags,
virDomainDefPtr *persistentDef)
"transient domain"));
goto cleanup;
}
- if (!(*persistentDef = virDomainObjGetPersistentDef(caps, dom))) {
+ if (!(*persistentDef = virDomainObjGetPersistentDef(caps, xmlconf, dom))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Get persistent config failed"));
goto cleanup;
static virDomainDefPtr
virDomainDefParseXML(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
xmlDocPtr xml,
xmlNodePtr root,
xmlXPathContextPtr ctxt,
/* we have to make a copy of all of the callback pointers here since
* we won't have the virCaps structure available during free
*/
- def->ns = caps->ns;
+ def->ns = xmlconf->ns;
if (def->ns.parse &&
(def->ns.parse)(xml, root, ctxt, &def->namespaceData) < 0)
static virDomainObjPtr
virDomainObjParseXML(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
xmlDocPtr xml,
xmlXPathContextPtr ctxt,
unsigned int expectedVirtTypes,
int state;
int reason = 0;
- if (!(obj = virDomainObjNew(caps)))
+ if (!(obj = virDomainObjNew(xmlconf)))
return NULL;
if (!(config = virXPathNode("./domain", ctxt))) {
oldnode = ctxt->node;
ctxt->node = config;
- obj->def = virDomainDefParseXML(caps, xml, config, ctxt, expectedVirtTypes,
+ obj->def = virDomainDefParseXML(caps, xmlconf, xml, config, ctxt, expectedVirtTypes,
flags);
ctxt->node = oldnode;
if (!obj->def)
}
VIR_FREE(nodes);
- if (caps->privateDataXMLParse &&
- ((caps->privateDataXMLParse)(ctxt, obj->privateData)) < 0)
+ if (xmlconf->privateData.parse &&
+ ((xmlconf->privateData.parse)(ctxt, obj->privateData)) < 0)
goto error;
return obj;
virDomainDefParse(const char *xmlStr,
const char *filename,
virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
unsigned int expectedVirtTypes,
unsigned int flags)
{
int keepBlanksDefault = xmlKeepBlanksDefault(0);
if ((xml = virXMLParse(filename, xmlStr, _("(domain_definition)")))) {
- def = virDomainDefParseNode(caps, xml, xmlDocGetRootElement(xml),
+ def = virDomainDefParseNode(caps, xmlconf, xml, xmlDocGetRootElement(xml),
expectedVirtTypes, flags);
xmlFreeDoc(xml);
}
virDomainDefPtr
virDomainDefParseString(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const char *xmlStr,
unsigned int expectedVirtTypes,
unsigned int flags)
{
- return virDomainDefParse(xmlStr, NULL, caps, expectedVirtTypes, flags);
+ return virDomainDefParse(xmlStr, NULL, caps, xmlconf,
+ expectedVirtTypes, flags);
}
virDomainDefPtr
virDomainDefParseFile(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const char *filename,
unsigned int expectedVirtTypes,
unsigned int flags)
{
- return virDomainDefParse(NULL, filename, caps, expectedVirtTypes, flags);
+ return virDomainDefParse(NULL, filename, caps, xmlconf,
+ expectedVirtTypes, flags);
}
virDomainDefPtr
virDomainDefParseNode(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
xmlDocPtr xml,
xmlNodePtr root,
unsigned int expectedVirtTypes,
}
ctxt->node = root;
- def = virDomainDefParseXML(caps, xml, root, ctxt, expectedVirtTypes, flags);
+ def = virDomainDefParseXML(caps, xmlconf, xml, root, ctxt,
+ expectedVirtTypes, flags);
cleanup:
xmlXPathFreeContext(ctxt);
static virDomainObjPtr
virDomainObjParseNode(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
xmlDocPtr xml,
xmlNodePtr root,
unsigned int expectedVirtTypes,
}
ctxt->node = root;
- obj = virDomainObjParseXML(caps, xml, ctxt, expectedVirtTypes, flags);
+ obj = virDomainObjParseXML(caps, xmlconf, xml, ctxt, expectedVirtTypes, flags);
cleanup:
xmlXPathFreeContext(ctxt);
static virDomainObjPtr
virDomainObjParseFile(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const char *filename,
unsigned int expectedVirtTypes,
unsigned int flags)
int keepBlanksDefault = xmlKeepBlanksDefault(0);
if ((xml = virXMLParseFile(filename))) {
- obj = virDomainObjParseNode(caps, xml,
+ obj = virDomainObjParseNode(caps, xmlconf, xml,
xmlDocGetRootElement(xml),
expectedVirtTypes, flags);
xmlFreeDoc(xml);
static char *
-virDomainObjFormat(virCapsPtr caps,
+virDomainObjFormat(virDomainXMLConfPtr xmlconf,
virDomainObjPtr obj,
unsigned int flags)
{
virDomainTaintTypeToString(i));
}
- if (caps->privateDataXMLFormat &&
- ((caps->privateDataXMLFormat)(&buf, obj->privateData)) < 0)
+ if (xmlconf->privateData.format &&
+ ((xmlconf->privateData.format)(&buf, obj->privateData)) < 0)
goto error;
virBufferAdjustIndent(&buf, 2);
}
int
-virDomainSaveStatus(virCapsPtr caps,
+virDomainSaveStatus(virDomainXMLConfPtr xmlconf,
const char *statusDir,
virDomainObjPtr obj)
{
int ret = -1;
char *xml;
- if (!(xml = virDomainObjFormat(caps, obj, flags)))
+ if (!(xml = virDomainObjFormat(xmlconf, obj, flags)))
goto cleanup;
if (virDomainSaveXML(statusDir, obj->def, xml))
static virDomainObjPtr
virDomainObjListLoadConfig(virDomainObjListPtr doms,
virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const char *configDir,
const char *autostartDir,
const char *name,
if ((configFile = virDomainConfigFile(configDir, name)) == NULL)
goto error;
- if (!(def = virDomainDefParseFile(caps, configFile, expectedVirtTypes,
+ if (!(def = virDomainDefParseFile(caps, xmlconf, configFile,
+ expectedVirtTypes,
VIR_DOMAIN_XML_INACTIVE)))
goto error;
if ((autostart = virFileLinkPointsTo(autostartLink, configFile)) < 0)
goto error;
- if (!(dom = virDomainObjListAddLocked(doms, caps, def, 0, &oldDef)))
+ if (!(dom = virDomainObjListAddLocked(doms, xmlconf, def, 0, &oldDef)))
goto error;
dom->autostart = autostart;
static virDomainObjPtr
virDomainObjListLoadStatus(virDomainObjListPtr doms,
virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const char *statusDir,
const char *name,
unsigned int expectedVirtTypes,
if ((statusFile = virDomainConfigFile(statusDir, name)) == NULL)
goto error;
- if (!(obj = virDomainObjParseFile(caps, statusFile, expectedVirtTypes,
+ if (!(obj = virDomainObjParseFile(caps, xmlconf, statusFile, expectedVirtTypes,
VIR_DOMAIN_XML_INTERNAL_STATUS |
VIR_DOMAIN_XML_INTERNAL_ACTUAL_NET |
VIR_DOMAIN_XML_INTERNAL_PCI_ORIG_STATES)))
int
virDomainObjListLoadAllConfigs(virDomainObjListPtr doms,
virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const char *configDir,
const char *autostartDir,
int liveStatus,
if (liveStatus)
dom = virDomainObjListLoadStatus(doms,
caps,
+ xmlconf,
configDir,
entry->d_name,
expectedVirtTypes,
else
dom = virDomainObjListLoadConfig(doms,
caps,
+ xmlconf,
configDir,
autostartDir,
entry->d_name,
* persistent and active, true for transitions across save files or
* snapshots). */
virDomainDefPtr
-virDomainDefCopy(virCapsPtr caps, virDomainDefPtr src, bool migratable)
+virDomainDefCopy(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
+ virDomainDefPtr src,
+ bool migratable)
{
char *xml;
virDomainDefPtr ret;
if (!(xml = virDomainDefFormat(src, write_flags)))
return NULL;
- ret = virDomainDefParseString(caps, xml, -1, read_flags);
+ ret = virDomainDefParseString(caps, xmlconf, xml, -1, read_flags);
VIR_FREE(xml);
return ret;
}
virDomainDefPtr
-virDomainObjCopyPersistentDef(virCapsPtr caps, virDomainObjPtr dom)
+virDomainObjCopyPersistentDef(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
+ virDomainObjPtr dom)
{
virDomainDefPtr cur;
- cur = virDomainObjGetPersistentDef(caps, dom);
- return virDomainDefCopy(caps, cur, false);
+ cur = virDomainObjGetPersistentDef(caps, xmlconf, dom);
+ return virDomainDefCopy(caps, xmlconf, cur, false);
}
typedef struct _virDomainObjList virDomainObjList;
typedef virDomainObjList *virDomainObjListPtr;
+
+/* This structure holds various callbacks and data needed
+ * while parsing and creating domain XMLs */
+typedef struct _virDomainXMLConf virDomainXMLConf;
+typedef virDomainXMLConf *virDomainXMLConfPtr;
+
+typedef void *(*virDomainXMLPrivateDataAllocFunc)(void);
+typedef void (*virDomainXMLPrivateDataFreeFunc)(void *);
+typedef int (*virDomainXMLPrivateDataFormatFunc)(virBufferPtr, void *);
+typedef int (*virDomainXMLPrivateDataParseFunc)(xmlXPathContextPtr, void *);
+
+typedef struct _virDomainXMLPrivateDataCallbacks virDomainXMLPrivateDataCallbacks;
+typedef virDomainXMLPrivateDataCallbacks *virDomainXMLPrivateDataCallbacksPtr;
+struct _virDomainXMLPrivateDataCallbacks {
+ virDomainXMLPrivateDataAllocFunc alloc;
+ virDomainXMLPrivateDataFreeFunc free;
+ virDomainXMLPrivateDataFormatFunc format;
+ virDomainXMLPrivateDataParseFunc parse;
+};
+
+virDomainXMLConfPtr
+virDomainXMLConfNew(virDomainXMLPrivateDataCallbacksPtr priv,
+ virDomainXMLNamespacePtr xmlns);
+
+virDomainXMLNamespacePtr
+virDomainXMLConfGetNamespace(virDomainXMLConfPtr xmlconf)
+ ATTRIBUTE_NONNULL(1);
+
static inline bool
virDomainObjIsActive(virDomainObjPtr dom)
{
return dom->def->id != -1;
}
-virDomainObjPtr virDomainObjNew(virCapsPtr caps);
+virDomainObjPtr virDomainObjNew(virDomainXMLConfPtr caps)
+ ATTRIBUTE_NONNULL(1);
virDomainObjListPtr virDomainObjListNew(void);
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE = (1 << 1),
};
virDomainObjPtr virDomainObjListAdd(virDomainObjListPtr doms,
- virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const virDomainDefPtr def,
unsigned int flags,
virDomainDefPtr *oldDef);
bool live,
virDomainDefPtr *oldDef);
int virDomainObjSetDefTransient(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
virDomainObjPtr domain,
bool live);
virDomainDefPtr
virDomainObjGetPersistentDef(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
virDomainObjPtr domain);
int
virDomainLiveConfigHelperMethod(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
virDomainObjPtr dom,
unsigned int *flags,
virDomainDefPtr *persistentDef);
-virDomainDefPtr virDomainDefCopy(virCapsPtr caps, virDomainDefPtr src,
- bool migratable);
+virDomainDefPtr virDomainDefCopy(virCapsPtr caps, virDomainXMLConfPtr xmlconf,
+ virDomainDefPtr src, bool migratable);
virDomainDefPtr
-virDomainObjCopyPersistentDef(virCapsPtr caps, virDomainObjPtr dom);
+virDomainObjCopyPersistentDef(virCapsPtr caps, virDomainXMLConfPtr xmlconf,
+ virDomainObjPtr dom);
void virDomainObjListRemove(virDomainObjListPtr doms,
virDomainObjPtr dom);
const char *xmlStr,
unsigned int flags);
virDomainDefPtr virDomainDefParseString(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const char *xmlStr,
unsigned int expectedVirtTypes,
unsigned int flags);
virDomainDefPtr virDomainDefParseFile(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const char *filename,
unsigned int expectedVirtTypes,
unsigned int flags);
virDomainDefPtr virDomainDefParseNode(virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
xmlDocPtr doc,
xmlNodePtr root,
unsigned int expectedVirtTypes,
int virDomainSaveConfig(const char *configDir,
virDomainDefPtr def);
-int virDomainSaveStatus(virCapsPtr caps,
+int virDomainSaveStatus(virDomainXMLConfPtr xmlconf,
const char *statusDir,
virDomainObjPtr obj) ATTRIBUTE_RETURN_CHECK;
int virDomainObjListLoadAllConfigs(virDomainObjListPtr doms,
virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
const char *configDir,
const char *autostartDir,
int liveStatus,
virDomainSnapshotDefPtr
virDomainSnapshotDefParseString(const char *xmlStr,
virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
unsigned int expectedVirtTypes,
unsigned int flags)
{
_("missing domain in snapshot"));
goto cleanup;
}
- def->dom = virDomainDefParseNode(caps, xml, domainNode,
+ def->dom = virDomainDefParseNode(caps, xmlconf, xml, domainNode,
expectedVirtTypes,
(VIR_DOMAIN_XML_INACTIVE |
VIR_DOMAIN_XML_SECURE));
virDomainSnapshotDefPtr virDomainSnapshotDefParseString(const char *xmlStr,
virCapsPtr caps,
+ virDomainXMLConfPtr xmlconf,
unsigned int expectedVirtTypes,
unsigned int flags);
void virDomainSnapshotDefFree(virDomainSnapshotDefPtr def);
esxVI_Context_Free(&(*priv)->vCenter);
esxUtil_FreeParsedUri(&(*priv)->parsedUri);
virObjectUnref((*priv)->caps);
+ virObjectUnref((*priv)->xmlconf);
VIR_FREE(*priv);
}
goto cleanup;
}
+ if (!(priv->xmlconf = virDomainXMLConfNew(NULL, NULL)))
+ goto cleanup;
+
conn->privateData = priv;
priv = NULL;
result = VIR_DRV_OPEN_SUCCESS;
return NULL;
}
- def = virDomainDefParseString(priv->caps, domainXml,
- 1 << VIR_DOMAIN_VIRT_VMWARE, 0);
+ def = virDomainDefParseString(priv->caps, priv->xmlconf,
+ domainXml, 1 << VIR_DOMAIN_VIRT_VMWARE, 0);
if (def == NULL) {
return NULL;
}
/* Parse domain XML */
- def = virDomainDefParseString(priv->caps, xml, 1 << VIR_DOMAIN_VIRT_VMWARE,
+ def = virDomainDefParseString(priv->caps, priv->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_VMWARE,
VIR_DOMAIN_XML_INACTIVE);
if (def == NULL) {
return NULL;
}
- def = virDomainSnapshotDefParseString(xmlDesc, NULL, 0, 0);
+ def = virDomainSnapshotDefParseString(xmlDesc, priv->caps,
+ priv->xmlconf, 0, 0);
if (def == NULL) {
return NULL;
# include "internal.h"
# include "virerror.h"
# include "capabilities.h"
+# include "domain_conf.h"
# include "esx_vi.h"
typedef struct _esxPrivate {
esxVI_Context *vCenter;
esxUtil_ParsedUri *parsedUri;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
int32_t maxVcpus;
esxVI_Boolean supportsVMotion;
esxVI_Boolean supportsLongMode; /* aka x86_64 */
virDomainWatchdogActionTypeToString;
virDomainWatchdogModelTypeFromString;
virDomainWatchdogModelTypeToString;
+virDomainXMLConfGetNamespace;
+virDomainXMLConfNew;
# conf/domain_event.h
struct _libxlDriverPrivate {
virMutex lock;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
unsigned int version;
FILE *logger_file;
virObjectUnref(priv);
}
+virDomainXMLPrivateDataCallbacks libxlDomainXMLPrivateDataCallbacks = {
+ .alloc = libxlDomainObjPrivateAlloc,
+ .free = libxlDomainObjPrivateFree,
+};
+
/* driver must be locked before calling */
static void
libxlDomainEventQueue(libxlDriverPrivatePtr driver, virDomainEventPtr event)
goto error;
}
- if (!(def = virDomainDefParseString(driver->caps, xml,
- 1 << VIR_DOMAIN_VIRT_XEN,
+ if (!(def = virDomainDefParseString(driver->caps, driver->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE)))
goto error;
}
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0)
goto error;
if (!driver->nactive && driver->inhibitCallback)
libxlDriverLock(libxl_driver);
virObjectUnref(libxl_driver->caps);
+ virObjectUnref(libxl_driver->xmlconf);
virObjectUnref(libxl_driver->domains);
libxl_ctx_free(libxl_driver->ctx);
xtl_logger_destroy(libxl_driver->logger);
goto error;
}
- libxl_driver->caps->privateDataAllocFunc = libxlDomainObjPrivateAlloc;
- libxl_driver->caps->privateDataFreeFunc = libxlDomainObjPrivateFree;
+ if (!(libxl_driver->xmlconf = virDomainXMLConfNew(&libxlDomainXMLPrivateDataCallbacks,
+ NULL)))
+ goto error;
/* Load running domains first. */
if (virDomainObjListLoadAllConfigs(libxl_driver->domains,
libxl_driver->caps,
+ libxl_driver->xmlconf,
libxl_driver->stateDir,
libxl_driver->autostartDir,
1, 1 << VIR_DOMAIN_VIRT_XEN,
/* Then inactive persistent configs */
if (virDomainObjListLoadAllConfigs(libxl_driver->domains,
libxl_driver->caps,
+ libxl_driver->xmlconf,
libxl_driver->configDir,
libxl_driver->autostartDir,
0, 1 << VIR_DOMAIN_VIRT_XEN,
libxlDriverLock(libxl_driver);
virDomainObjListLoadAllConfigs(libxl_driver->domains,
libxl_driver->caps,
+ libxl_driver->xmlconf,
libxl_driver->configDir,
libxl_driver->autostartDir,
1, 1 << VIR_DOMAIN_VIRT_XEN,
virCheckFlags(VIR_DOMAIN_START_PAUSED, NULL);
libxlDriverLock(driver);
- if (!(def = virDomainDefParseString(driver->caps, xml,
- 1 << VIR_DOMAIN_VIRT_XEN,
+ if (!(def = virDomainDefParseString(driver->caps, driver->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);
}
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0)
goto cleanup;
ret = 0;
VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);
}
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0)
goto cleanup;
ret = 0;
_("cannot change persistent config of a transient domain"));
goto cleanup;
}
- if (!(persistentDef = virDomainObjGetPersistentDef(driver->caps, vm)))
+ if (!(persistentDef = virDomainObjGetPersistentDef(driver->caps,
+ driver->xmlconf,
+ vm)))
goto cleanup;
}
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
priv = vm->privateData;
- if (!(def = virDomainObjGetPersistentDef(driver->caps, vm)))
+ if (!(def = virDomainObjGetPersistentDef(driver->caps, driver->xmlconf, vm)))
goto cleanup;
maplen = VIR_CPU_MAPLEN(nvcpus);
goto cleanup;
}
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0)
goto cleanup;
ret = 0;
goto cleanup;
}
- if (!(def = virDomainDefParseString(driver->caps, domainXml,
+ if (!(def = virDomainDefParseString(driver->caps, driver->xmlconf, domainXml,
1 << VIR_DOMAIN_VIRT_XEN, 0)))
goto cleanup;
virDomainDefPtr oldDef = NULL;
libxlDriverLock(driver);
- if (!(def = virDomainDefParseString(driver->caps, xml,
+ if (!(def = virDomainDefParseString(driver->caps, driver->xmlconf, xml,
1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
def,
0,
&oldDef)))
goto cleanup;
/* Make a copy for updated domain. */
- if (!(vmdef = virDomainObjCopyPersistentDef(driver->caps, vm)))
+ if (!(vmdef = virDomainObjCopyPersistentDef(driver->caps,
+ driver->xmlconf, vm)))
goto cleanup;
switch (action) {
* update domain status forcibly because the domain status may be
* changed even if we attach the device failed.
*/
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0)
ret = -1;
}
#include <config.h>
#include "lxc_conf.h"
+#include "lxc_domain.h"
#include "nodeinfo.h"
#include "virerror.h"
#include "virconf.h"
return NULL;
}
+
+virDomainXMLConfPtr
+lxcDomainXMLConfInit(void)
+{
+ return virDomainXMLConfNew(&virLXCDriverPrivateDataCallbacks, NULL);
+}
+
int lxcLoadDriverConfig(virLXCDriverPtr driver)
{
char *filename;
virMutex lock;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
virCgroupPtr cgroup;
int lxcLoadDriverConfig(virLXCDriverPtr driver);
virCapsPtr lxcCapsInit(virLXCDriverPtr driver);
+virDomainXMLConfPtr lxcDomainXMLConfInit(void);
static inline void lxcDriverLock(virLXCDriverPtr driver)
{
{
virLXCControllerPtr ctrl = NULL;
virCapsPtr caps = NULL;
+ virDomainXMLConfPtr xmlconf = NULL;
char *configFile = NULL;
if (VIR_ALLOC(ctrl) < 0)
if ((caps = lxcCapsInit(NULL)) == NULL)
goto error;
+ if (!(xmlconf = lxcDomainXMLConfInit()))
+ goto error;
+
if ((configFile = virDomainConfigFile(LXC_STATE_DIR,
ctrl->name)) == NULL)
goto error;
- if ((ctrl->def = virDomainDefParseFile(caps,
+ if ((ctrl->def = virDomainDefParseFile(caps, xmlconf,
configFile,
1 << VIR_DOMAIN_VIRT_LXC,
0)) == NULL)
cleanup:
VIR_FREE(configFile);
virObjectUnref(caps);
+ virObjectUnref(xmlconf);
return ctrl;
no_memory:
return 0;
}
-void virLXCDomainSetPrivateDataHooks(virCapsPtr caps)
-{
- caps->privateDataAllocFunc = virLXCDomainObjPrivateAlloc;
- caps->privateDataFreeFunc = virLXCDomainObjPrivateFree;
- caps->privateDataXMLFormat = virLXCDomainObjPrivateXMLFormat;
- caps->privateDataXMLParse = virLXCDomainObjPrivateXMLParse;
-}
+virDomainXMLPrivateDataCallbacks virLXCDriverPrivateDataCallbacks = {
+ .alloc = virLXCDomainObjPrivateAlloc,
+ .free = virLXCDomainObjPrivateFree,
+ .format = virLXCDomainObjPrivateXMLFormat,
+ .parse = virLXCDomainObjPrivateXMLParse,
+};
pid_t initpid;
};
-void virLXCDomainSetPrivateDataHooks(virCapsPtr caps);
+extern virDomainXMLPrivateDataCallbacks virLXCDriverPrivateDataCallbacks;
#endif /* __LXC_DOMAIN_H__ */
virDomainDefPtr oldDef = NULL;
lxcDriverLock(driver);
- if (!(def = virDomainDefParseString(driver->caps, xml,
+ if (!(def = virDomainDefParseString(driver->caps, driver->xmlconf, xml,
1 << VIR_DOMAIN_VIRT_LXC,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
}
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
def,
0,
&oldDef)))
virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, NULL);
lxcDriverLock(driver);
- if (!(def = virDomainDefParseString(driver->caps, xml,
+ if (!(def = virDomainDefParseString(driver->caps, driver->xmlconf, xml,
1 << VIR_DOMAIN_VIRT_LXC,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
if ((lxc_driver->caps = lxcCapsInit(lxc_driver)) == NULL)
goto cleanup;
- virLXCDomainSetPrivateDataHooks(lxc_driver->caps);
+ if (!(lxc_driver->xmlconf = lxcDomainXMLConfInit()))
+ goto cleanup;
if (virLXCProcessAutoDestroyInit(lxc_driver) < 0)
goto cleanup;
/* Get all the running persistent or transient configs first */
if (virDomainObjListLoadAllConfigs(lxc_driver->domains,
lxc_driver->caps,
+ lxc_driver->xmlconf,
lxc_driver->stateDir,
NULL,
1, 1 << VIR_DOMAIN_VIRT_LXC,
/* Then inactive persistent configs */
if (virDomainObjListLoadAllConfigs(lxc_driver->domains,
lxc_driver->caps,
+ lxc_driver->xmlconf,
lxc_driver->configDir,
lxc_driver->autostartDir,
0, 1 << VIR_DOMAIN_VIRT_LXC,
lxcDriverLock(lxc_driver);
virDomainObjListLoadAllConfigs(lxc_driver->domains,
lxc_driver->caps,
+ lxc_driver->xmlconf,
lxc_driver->configDir,
lxc_driver->autostartDir,
0, 1 << VIR_DOMAIN_VIRT_LXC,
virObjectUnref(lxc_driver->activeUsbHostdevs);
virObjectUnref(lxc_driver->caps);
virObjectUnref(lxc_driver->securityManager);
+ virObjectUnref(lxc_driver->xmlconf);
VIR_FREE(lxc_driver->configDir);
VIR_FREE(lxc_driver->autostartDir);
VIR_FREE(lxc_driver->stateDir);
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
- &vmdef) < 0)
+ if (virDomainLiveConfigHelperMethod(driver->caps, driver->xmlconf,
+ vm, &flags, &vmdef) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
/* Make a copy for updated domain. */
- vmdef = virDomainObjCopyPersistentDef(driver->caps, vm);
+ vmdef = virDomainObjCopyPersistentDef(driver->caps, driver->xmlconf, vm);
if (!vmdef)
goto cleanup;
}
}
}
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0)
goto cleanup;
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
- &persistentDef) < 0)
+ if (virDomainLiveConfigHelperMethod(driver->caps, driver->xmlconf,
+ vm, &flags, &persistentDef) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
- &persistentDef) < 0)
+ if (virDomainLiveConfigHelperMethod(driver->caps, driver->xmlconf,
+ vm, &flags, &persistentDef) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
- &persistentDef) < 0)
+ if (virDomainLiveConfigHelperMethod(driver->caps, driver->xmlconf,
+ vm, &flags, &persistentDef) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);
}
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0)
goto cleanup;
ret = 0;
VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);
}
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0)
goto cleanup;
ret = 0;
goto cleanup;
/* Make a copy for updated domain. */
- vmdef = virDomainObjCopyPersistentDef(driver->caps, vm);
+ vmdef = virDomainObjCopyPersistentDef(driver->caps, driver->xmlconf, vm);
if (!vmdef)
goto cleanup;
switch (action) {
* changed even if we failed to attach the device. For example,
* a new controller may be created.
*/
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0) {
ret = -1;
goto cleanup;
}
}
virDomainAuditInit(vm, initpid, inode);
- if (virDomainSaveStatus(lxc_driver->caps, lxc_driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(lxc_driver->xmlconf, lxc_driver->stateDir, vm) < 0)
VIR_WARN("Cannot update XML with PID for LXC %s", vm->def->name);
}
* report implicit runtime defaults in the XML, like vnc listen/socket
*/
VIR_DEBUG("Setting current domain def as transient");
- if (virDomainObjSetDefTransient(driver->caps, vm, true) < 0)
+ if (virDomainObjSetDefTransient(driver->caps, driver->xmlconf, vm, true) < 0)
goto cleanup;
/* Run an early hook to set-up missing devices */
virLXCProcessAutoDestroyAdd(driver, vm, conn) < 0)
goto error;
- if (virDomainObjSetDefTransient(driver->caps, vm, false) < 0)
+ if (virDomainObjSetDefTransient(driver->caps, driver->xmlconf,
+ vm, false) < 0)
goto error;
/* Write domain status to disk.
* location for the benefit of libvirt_lxc. We're now overwriting
* it with the live status XML instead. This is a (currently
* harmless) inconsistency we should fix one day */
- if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, driver->stateDir, vm) < 0)
goto error;
/* finally we can call the 'started' hook script if any */
if (!driver)
return;
+ virObjectUnref(driver->xmlconf);
virObjectUnref(driver->domains);
virObjectUnref(driver->caps);
VIR_FREE(driver);
flags |= VIR_DOMAIN_OBJ_LIST_ADD_LIVE;
if (!(dom = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
def,
flags,
NULL)))
virMutex lock;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
virDomainObjListPtr domains;
int version;
};
virDomainPtr dom = NULL;
openvzDriverLock(driver);
- if ((vmdef = virDomainDefParseString(driver->caps, xml,
- 1 << VIR_DOMAIN_VIRT_OPENVZ,
+ if ((vmdef = virDomainDefParseString(driver->caps, driver->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_OPENVZ,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
goto cleanup;
}
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
vmdef, 0, NULL)))
goto cleanup;
vmdef = NULL;
virCheckFlags(0, NULL);
openvzDriverLock(driver);
- if ((vmdef = virDomainDefParseString(driver->caps, xml,
- 1 << VIR_DOMAIN_VIRT_OPENVZ,
+ if ((vmdef = virDomainDefParseString(driver->caps, driver->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_OPENVZ,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
goto cleanup;
}
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
vmdef,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
if (!(driver->caps = openvzCapsInit()))
goto cleanup;
+ if (!(driver->xmlconf = virDomainXMLConfNew(NULL, NULL)))
+ goto cleanup;
+
if (openvzLoadDomains(driver) < 0)
goto cleanup;
}
if (virDomainLiveConfigHelperMethod(driver->caps,
+ driver->xmlconf,
vm,
&flags,
&vmdef) < 0)
goto cleanup;
if (!(dom = virDomainObjListAdd(privconn->domains,
- privconn->caps,
+ privconn->xmlconf,
def, 0, NULL)))
goto cleanup;
/* dom is locked here */
if (!(privconn->caps = parallelsBuildCapabilities()))
goto error;
+ if (!(privconn->xmlconf = virDomainXMLConfNew(NULL, NULL)))
+ goto error;
+
if (!(privconn->domains = virDomainObjListNew()))
goto error;
parallelsDriverLock(privconn);
virObjectUnref(privconn->caps);
+ virObjectUnref(privconn->xmlconf);
virObjectUnref(privconn->domains);
conn->privateData = NULL;
virDomainObjPtr dom = NULL, olddom = NULL;
parallelsDriverLock(privconn);
- if ((def = virDomainDefParseString(privconn->caps, xml,
- 1 << VIR_DOMAIN_VIRT_PARALLELS,
+ if ((def = virDomainDefParseString(privconn->caps, privconn->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_PARALLELS,
VIR_DOMAIN_XML_INACTIVE)) == NULL) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("Can't parse XML desc"));
virObjectUnlock(olddom);
if (!(dom = virDomainObjListAdd(privconn->domains,
- privconn->caps,
+ privconn->xmlconf,
def, 0, NULL))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Can't allocate domobj"));
virStoragePoolObjList pools;
virNetworkObjList networks;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
virDomainEventStatePtr domainEventState;
};
goto failure;
}
+ if (!(phyp_driver->xmlconf = virDomainXMLConfNew(NULL, NULL)))
+ goto failure;
+
conn->privateData = phyp_driver;
conn->networkPrivateData = connection_data;
libssh2_session_free(session);
virObjectUnref(phyp_driver->caps);
+ virObjectUnref(phyp_driver->xmlconf);
phypUUIDTable_Free(phyp_driver->uuid_table);
VIR_FREE(phyp_driver->managed_system);
VIR_FREE(phyp_driver);
virCheckFlags(0, NULL);
- if (!(def = virDomainDefParseString(phyp_driver->caps, xml,
- 1 << VIR_DOMAIN_VIRT_PHYP,
+ if (!(def = virDomainDefParseString(phyp_driver->caps, phyp_driver->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_PHYP,
VIR_DOMAIN_XML_SECURE)))
goto err;
struct _phyp_driver {
uuid_tablePtr uuid_table;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
int vios_id;
/* system_type:
* as is practical. This is not an exact science....
*/
virDomainDefPtr qemuParseCommandLine(virCapsPtr qemuCaps,
+ virDomainXMLConfPtr xmlconf,
const char **progenv,
const char **progargv,
char **pidfile,
goto error;
if (cmd->num_args || cmd->num_env) {
- def->ns = qemuCaps->ns;
+ def->ns = *virDomainXMLConfGetNamespace(xmlconf);
def->namespaceData = cmd;
}
else
virDomainDefPtr qemuParseCommandLineString(virCapsPtr qemuCaps,
+ virDomainXMLConfPtr xmlconf,
const char *args,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
if (qemuStringToArgvEnv(args, &progenv, &progargv) < 0)
goto cleanup;
- def = qemuParseCommandLine(qemuCaps, progenv, progargv,
+ def = qemuParseCommandLine(qemuCaps, xmlconf, progenv, progargv,
pidfile, monConfig, monJSON);
cleanup:
}
virDomainDefPtr qemuParseCommandLinePid(virCapsPtr qemuCaps,
+ virDomainXMLConfPtr xmlconf,
pid_t pid,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
qemuParseProcFileStrings(pid, "environ", &progenv) < 0)
goto cleanup;
- if (!(def = qemuParseCommandLine(qemuCaps, progenv, progargv,
+ if (!(def = qemuParseCommandLine(qemuCaps, xmlconf, progenv, progargv,
pidfile, monConfig, monJSON)))
goto cleanup;
* *must* decide how to fill in a name in this case
*/
virDomainDefPtr qemuParseCommandLine(virCapsPtr qemuCaps,
+ virDomainXMLConfPtr xmlconf,
const char **progenv,
const char **progargv,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
bool *monJSON);
virDomainDefPtr qemuParseCommandLineString(virCapsPtr qemuCaps,
+ virDomainXMLConfPtr xmlconf,
const char *args,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
bool *monJSON);
virDomainDefPtr qemuParseCommandLinePid(virCapsPtr qemuCaps,
+ virDomainXMLConfPtr xmlconf,
pid_t pid,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
return conf;
}
+virDomainXMLConfPtr
+virQEMUDriverCreateXMLConf(void)
+{
+ return virDomainXMLConfNew(&virQEMUDriverPrivateDataCallbacks,
+ &virQEMUDriverDomainXMLNamespace);
+}
+
virCapsPtr virQEMUDriverCreateCapabilities(virQEMUDriverPtr driver)
{
caps->defaultDiskDriverType = VIR_STORAGE_FILE_RAW;
}
- qemuDomainSetPrivateDataHooks(caps);
- qemuDomainSetNamespaceHooks(caps);
-
if (virGetHostUUID(caps->host.host_uuid)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("cannot get the host uuid"));
*/
virCapsPtr caps;
+ /* Immutable pointer, Immutable object */
+ virDomainXMLConfPtr xmlconf;
+
/* Immutable pointer, self-locking APIs */
virQEMUCapsCachePtr qemuCapsCache;
ATTRIBUTE_NONNULL(1);
int qemuDriverAllocateID(virQEMUDriverPtr driver);
+virDomainXMLConfPtr virQEMUDriverCreateXMLConf(void);
#endif /* __QEMUD_CONF_H */
}
-static void *qemuDomainObjPrivateAlloc(void)
+static void
+*qemuDomainObjPrivateAlloc(void)
{
qemuDomainObjPrivatePtr priv;
return NULL;
}
-static void qemuDomainObjPrivateFree(void *data)
+static void
+qemuDomainObjPrivateFree(void *data)
{
qemuDomainObjPrivatePtr priv = data;
}
-static int qemuDomainObjPrivateXMLFormat(virBufferPtr buf, void *data)
+static int
+qemuDomainObjPrivateXMLFormat(virBufferPtr buf, void *data)
{
qemuDomainObjPrivatePtr priv = data;
const char *monitorpath;
return 0;
}
-static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
+static int
+qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
{
qemuDomainObjPrivatePtr priv = data;
char *monitorpath;
}
+virDomainXMLPrivateDataCallbacks virQEMUDriverPrivateDataCallbacks = {
+ .alloc = qemuDomainObjPrivateAlloc,
+ .free = qemuDomainObjPrivateFree,
+ .parse = qemuDomainObjPrivateXMLParse,
+ .format = qemuDomainObjPrivateXMLFormat,
+};
+
+
static void
qemuDomainDefNamespaceFree(void *nsdata)
{
}
-void qemuDomainSetPrivateDataHooks(virCapsPtr caps)
-{
- /* Domain XML parser hooks */
- caps->privateDataAllocFunc = qemuDomainObjPrivateAlloc;
- caps->privateDataFreeFunc = qemuDomainObjPrivateFree;
- caps->privateDataXMLFormat = qemuDomainObjPrivateXMLFormat;
- caps->privateDataXMLParse = qemuDomainObjPrivateXMLParse;
-
-}
+virDomainXMLNamespace virQEMUDriverDomainXMLNamespace = {
+ .parse = qemuDomainDefNamespaceParse,
+ .free = qemuDomainDefNamespaceFree,
+ .format = qemuDomainDefNamespaceFormatXML,
+ .href = qemuDomainDefNamespaceHref,
+};
-void qemuDomainSetNamespaceHooks(virCapsPtr caps)
-{
- /* Domain Namespace XML parser hooks */
- caps->ns.parse = qemuDomainDefNamespaceParse;
- caps->ns.free = qemuDomainDefNamespaceFree;
- caps->ns.format = qemuDomainDefNamespaceFormatXML;
- caps->ns.href = qemuDomainDefNamespaceHref;
-}
static void
qemuDomainObjSaveJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
{
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
if (virDomainObjIsActive(obj)) {
- if (virDomainSaveStatus(caps, cfg->stateDir, obj) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, obj) < 0)
VIR_WARN("Failed to save status on vm %s", obj->def->name);
}
-cleanup:
virObjectUnref(cfg);
- virObjectUnref(caps);
}
void
{
qemuDomainObjPrivatePtr priv = vm->privateData;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
if (priv->fakeReboot == value)
goto cleanup;
priv->fakeReboot = value;
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
VIR_WARN("Failed to save status on vm %s", vm->def->name);
cleanup:
virObjectUnref(cfg);
- virObjectUnref(caps);
}
int
void qemuDomainEventQueue(virQEMUDriverPtr driver,
virDomainEventPtr event);
-void qemuDomainSetPrivateDataHooks(virCapsPtr caps);
-void qemuDomainSetNamespaceHooks(virCapsPtr caps);
-
int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainJob job)
void qemuDomainCleanupRun(virQEMUDriverPtr driver,
virDomainObjPtr vm);
+extern virDomainXMLPrivateDataCallbacks virQEMUDriverPrivateDataCallbacks;
+extern virDomainXMLNamespace virQEMUDriverDomainXMLNamespace;
+
#endif /* __QEMU_DOMAIN_H__ */
}
def = virDomainSnapshotDefParseString(xmlStr, caps,
+ qemu_driver->xmlconf,
QEMU_EXPECTED_VIRT_TYPES,
flags);
if (def == NULL) {
if ((qemu_driver->caps = virQEMUDriverCreateCapabilities(qemu_driver)) == NULL)
goto error;
+ if (!(qemu_driver->xmlconf = virQEMUDriverCreateXMLConf()))
+ goto error;
+
/* If hugetlbfs is present, then we need to create a sub-directory within
* it, since we can't assume the root mount point has permissions that
* will let our spawned QEMU instances use it.
/* Get all the running persistent or transient configs first */
if (virDomainObjListLoadAllConfigs(qemu_driver->domains,
qemu_driver->caps,
+ qemu_driver->xmlconf,
cfg->stateDir,
NULL,
1, QEMU_EXPECTED_VIRT_TYPES,
/* Then inactive persistent configs */
if (virDomainObjListLoadAllConfigs(qemu_driver->domains,
qemu_driver->caps,
+ qemu_driver->xmlconf,
cfg->configDir,
cfg->autostartDir,
0, QEMU_EXPECTED_VIRT_TYPES,
cfg = virQEMUDriverGetConfig(qemu_driver);
virDomainObjListLoadAllConfigs(qemu_driver->domains,
caps,
+ qemu_driver->xmlconf,
cfg->configDir,
cfg->autostartDir,
0, QEMU_EXPECTED_VIRT_TYPES,
virObjectUnref(qemu_driver->domains);
virObjectUnref(qemu_driver->remotePorts);
+ virObjectUnref(qemu_driver->xmlconf);
+
virSysinfoDefFree(qemu_driver->hostsysinfo);
virObjectUnref(qemu_driver->closeCallbacks);
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (!(def = virDomainDefParseString(caps, xml,
+ if (!(def = virDomainDefParseString(caps, driver->xmlconf, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- caps,
+ driver->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
int eventDetail;
int state;
virQEMUDriverConfigPtr cfg = NULL;
- virCapsPtr caps = NULL;
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
eventDetail);
}
}
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto endjob;
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
goto endjob;
ret = 0;
if (event)
qemuDomainEventQueue(driver, event);
- virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
}
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto endjob;
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
goto endjob;
ret = 0;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto endjob;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto endjob;
if (xmlin) {
virDomainDefPtr def = NULL;
- if (!(def = virDomainDefParseString(caps, xmlin,
+ if (!(def = virDomainDefParseString(caps, driver->xmlconf, xmlin,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE))) {
goto endjob;
maximum = (flags & VIR_DOMAIN_VCPU_MAXIMUM) != 0;
flags &= ~VIR_DOMAIN_VCPU_MAXIMUM;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto endjob;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (newVcpuPin)
virDomainVcpuPinDefArrayFree(newVcpuPin, newVcpuPinNum);
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
goto cleanup;
}
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&targetDef) < 0)
goto cleanup;
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
goto cleanup;
}
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
goto cleanup;
}
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
- &targetDef) < 0)
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf,
+ vm, &flags, &targetDef) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE)
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags, &def) < 0)
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf,
+ vm, &flags, &def) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
header.was_running = state;
/* Create a domain from this XML */
- if (!(def = virDomainDefParseString(caps, xml,
+ if (!(def = virDomainDefParseString(caps, driver->xmlconf, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto error;
if (xmlin) {
virDomainDefPtr def2 = NULL;
- if (!(def2 = virDomainDefParseString(caps, xmlin,
+ if (!(def2 = virDomainDefParseString(caps, driver->xmlconf, xmlin,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto error;
virCommandPtr cmd = NULL;
char *errbuf = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
if ((header->version == 2) &&
(header->compressed != QEMU_SAVE_FORMAT_RAW)) {
"%s", _("failed to resume domain"));
goto cleanup;
}
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Failed to save status on vm %s", vm->def->name);
goto cleanup;
}
if (virSecurityManagerRestoreSavedStateLabel(driver->securityManager,
vm->def, path) < 0)
VIR_WARN("failed to restore save state label on %s", path);
- virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
virQEMUSaveHeader header;
virFileWrapperFdPtr wrapperFd = NULL;
int state = -1;
- virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_SAVE_BYPASS_CACHE |
VIR_DOMAIN_SAVE_RUNNING |
else if (flags & VIR_DOMAIN_SAVE_PAUSED)
state = 0;
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
-
fd = qemuDomainSaveImageOpen(driver, path, &def, &header,
(flags & VIR_DOMAIN_SAVE_BYPASS_CACHE) != 0,
&wrapperFd, dxml, state, false, false);
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- caps,
+ driver->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
virFileWrapperFdFree(wrapperFd);
if (vm)
virObjectUnlock(vm);
- virObjectUnref(caps);
return ret;
}
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- def = qemuParseCommandLineString(caps, config,
+ def = qemuParseCommandLineString(caps, driver->xmlconf, config,
NULL, NULL, NULL);
if (!def)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- def = virDomainDefParseString(caps, xmlData,
+ def = virDomainDefParseString(caps, driver->xmlconf, xmlData,
QEMU_EXPECTED_VIRT_TYPES, 0);
if (!def)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (!(def = virDomainDefParseString(caps, xml,
+ if (!(def = virDomainDefParseString(caps, driver->xmlconf, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- caps,
+ driver->xmlconf,
def,
0,
&oldDef)))
goto endjob;
/* Make a copy for updated domain. */
- vmdef = virDomainObjCopyPersistentDef(caps, vm);
+ vmdef = virDomainObjCopyPersistentDef(caps, driver->xmlconf, vm);
if (!vmdef)
goto endjob;
switch (action) {
* changed even if we failed to attach the device. For example,
* a new controller may be created.
*/
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
ret = -1;
goto endjob;
}
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&vmdef) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
/* Make a copy for updated domain. */
- vmdef = virDomainObjCopyPersistentDef(caps, vm);
+ vmdef = virDomainObjCopyPersistentDef(caps, driver->xmlconf, vm);
if (!vmdef)
goto cleanup;
}
}
}
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
bool reuse = (flags & VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT) != 0;
virCgroupPtr cgroup = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
if (!virDomainObjIsActive(vm)) {
virReportError(VIR_ERR_OPERATION_INVALID,
virCgroupFree(&cgroup);
if (ret == 0 || !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0 ||
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0 ||
(persist && virDomainSaveConfig(cfg->configDir, vm->newDef) < 0))
ret = -1;
}
- virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
!virDomainObjIsActive(vm))
parse_flags |= VIR_DOMAIN_SNAPSHOT_PARSE_OFFLINE;
- if (!(def = virDomainSnapshotDefParseString(xmlDesc, caps,
+ if (!(def = virDomainSnapshotDefParseString(xmlDesc, caps, driver->xmlconf,
QEMU_EXPECTED_VIRT_TYPES,
parse_flags)))
goto cleanup;
/* Easiest way to clone inactive portion of vm->def is via
* conversion in and back out of xml. */
if (!(xml = qemuDomainDefFormatLive(driver, vm->def, true, true)) ||
- !(def->dom = virDomainDefParseString(caps, xml,
+ !(def->dom = virDomainDefParseString(caps, driver->xmlconf, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
* than inactive xml? */
snap->def->current = true;
if (snap->def->dom) {
- config = virDomainDefCopy(caps, snap->def->dom, true);
+ config = virDomainDefCopy(caps, driver->xmlconf, snap->def->dom, true);
if (!config)
goto cleanup;
}
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (!(def = qemuParseCommandLinePid(caps, pid,
+ if (!(def = qemuParseCommandLinePid(caps, driver->xmlconf, pid,
&pidfile, &monConfig, &monJSON)))
goto cleanup;
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- caps,
+ driver->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto endjob;
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto endjob;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(caps, vm, &flags, &def) < 0)
+ if (virDomainLiveConfigHelperMethod(caps, driver->xmlconf, vm, &flags, &def) < 0)
goto cleanup;
/* use correct domain definition according to flags */
n);
goto error;
}
- mig->persistent = virDomainDefParseNode(caps, doc, nodes[0],
+ mig->persistent = virDomainDefParseNode(caps, driver->xmlconf,
+ doc, nodes[0],
-1, VIR_DOMAIN_XML_INACTIVE);
if (!mig->persistent) {
/* virDomainDefParseNode already reported
}
if (xmlin) {
- if (!(def = virDomainDefParseString(caps, xmlin,
+ if (!(def = virDomainDefParseString(caps, driver->xmlconf, xmlin,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
- if (!(def = virDomainDefParseString(caps, dom_xml,
+ if (!(def = virDomainDefParseString(caps, driver->xmlconf, dom_xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
virDomainDefPtr newdef;
VIR_DEBUG("Using hook-filtered domain XML: %s", xmlout);
- newdef = virDomainDefParseString(caps, xmlout,
+ newdef = virDomainDefParseString(caps, driver->xmlconf, xmlout,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE);
if (!newdef)
}
if (!(vm = virDomainObjListAdd(driver->domains,
- caps,
+ driver->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
if (mig->persistent)
vm->newDef = vmdef = mig->persistent;
else
- vmdef = virDomainObjGetPersistentDef(caps, vm);
+ vmdef = virDomainObjGetPersistentDef(caps, driver->xmlconf, vm);
if (!vmdef || virDomainSaveConfig(cfg->configDir, vmdef) < 0) {
/* Hmpf. Migration was successful, but making it persistent
* was not. If we report successful, then when this domain
}
if (virDomainObjIsActive(vm) &&
- virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Failed to save status on vm %s", vm->def->name);
goto endjob;
}
virDomainEventPtr event = NULL;
int rv = -1;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
VIR_DEBUG("driver=%p, conn=%p, vm=%p, cookiein=%s, cookieinlen=%d, "
"flags=%x, retcode=%d",
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
-
qemuMigrationJobSetPhase(driver, vm,
retcode == 0
? QEMU_MIGRATION_PHASE_CONFIRM3
event = virDomainEventNewFromObj(vm,
VIR_DOMAIN_EVENT_RESUMED,
VIR_DOMAIN_EVENT_RESUMED_MIGRATED);
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Failed to save status on vm %s", vm->def->name);
goto cleanup;
}
cleanup:
if (event)
qemuDomainEventQueue(driver, event);
- virObjectUnref(caps);
virObjectUnref(cfg);
return rv;
}
qemuDomainObjPrivatePtr priv;
virDomainEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
VIR_DEBUG("vm=%p", vm);
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
-
virObjectLock(vm);
priv = vm->privateData;
VIR_DOMAIN_EVENT_SHUTDOWN,
VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED);
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after state change",
vm->def->name);
}
unlock:
virObjectUnlock(vm);
-cleanup:
if (event)
qemuDomainEventQueue(driver, event);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
VIR_WARN("Unable to release lease on %s", vm->def->name);
VIR_DEBUG("Preserving lock state '%s'", NULLSTR(priv->lockState));
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after state change",
vm->def->name);
}
unlock:
virObjectUnlock(vm);
-
-cleanup:
if (event)
qemuDomainEventQueue(driver, event);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) {
}
VIR_FREE(priv->lockState);
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after state change",
vm->def->name);
}
unlock:
virObjectUnlock(vm);
-cleanup:
if (event)
qemuDomainEventQueue(driver, event);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
event = virDomainEventRTCChangeNewFromObj(vm, offset);
if (vm->def->clock.offset == VIR_DOMAIN_CLOCK_OFFSET_VARIABLE)
vm->def->clock.data.variable.adjustment = offset;
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
VIR_WARN("unable to save domain status with RTC change");
virObjectUnlock(vm);
-cleanup:
if (event)
qemuDomainEventQueue(driver, event);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
virDomainEventPtr watchdogEvent = NULL;
virDomainEventPtr lifecycleEvent = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
watchdogEvent = virDomainEventWatchdogNewFromObj(vm, action);
VIR_WARN("Unable to release lease on %s", vm->def->name);
VIR_DEBUG("Preserving lock state '%s'", NULLSTR(priv->lockState));
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after watchdog event",
vm->def->name);
}
if (vm)
virObjectUnlock(vm);
-
-cleanup:
if (watchdogEvent)
qemuDomainEventQueue(driver, watchdogEvent);
if (lifecycleEvent)
qemuDomainEventQueue(driver, lifecycleEvent);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
const char *devAlias;
virDomainDiskDefPtr disk;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
disk = qemuProcessFindDomainDiskByAlias(vm, diskAlias);
VIR_WARN("Unable to release lease on %s", vm->def->name);
VIR_DEBUG("Preserving lock state '%s'", NULLSTR(priv->lockState));
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
VIR_WARN("Unable to save status on vm %s after IO error", vm->def->name);
}
virObjectUnlock(vm);
-cleanup:
if (ioErrorEvent)
qemuDomainEventQueue(driver, ioErrorEvent);
if (ioErrorEvent2)
qemuDomainEventQueue(driver, ioErrorEvent2);
if (lifecycleEvent)
qemuDomainEventQueue(driver, lifecycleEvent);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
virDomainEventPtr event = NULL;
virDomainDiskDefPtr disk;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
disk = qemuProcessFindDomainDiskByAlias(vm, devAlias);
else if (reason == VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE)
disk->tray_status = VIR_DOMAIN_DISK_TRAY_CLOSED;
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after tray moved event",
vm->def->name);
}
}
virObjectUnlock(vm);
-cleanup:
if (event)
qemuDomainEventQueue(driver, event);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
virDomainEventPtr event = NULL;
virDomainEventPtr lifecycleEvent = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
event = virDomainEventPMWakeupNewFromObj(vm);
VIR_DOMAIN_EVENT_STARTED,
VIR_DOMAIN_EVENT_STARTED_WAKEUP);
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after wakeup event",
vm->def->name);
}
}
virObjectUnlock(vm);
-
-cleanup:
if (event)
qemuDomainEventQueue(driver, event);
if (lifecycleEvent)
qemuDomainEventQueue(driver, lifecycleEvent);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
virDomainEventPtr event = NULL;
virDomainEventPtr lifecycleEvent = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
event = virDomainEventPMSuspendNewFromObj(vm);
VIR_DOMAIN_EVENT_PMSUSPENDED,
VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY);
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after suspend event",
vm->def->name);
}
virObjectUnlock(vm);
-cleanup:
if (event)
qemuDomainEventQueue(driver, event);
if (lifecycleEvent)
qemuDomainEventQueue(driver, lifecycleEvent);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
virQEMUDriverPtr driver = qemu_driver;
virDomainEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
event = virDomainEventBalloonChangeNewFromObj(vm, actual);
vm->def->mem.cur_balloon, actual);
vm->def->mem.cur_balloon = actual;
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
VIR_WARN("unable to save domain status with balloon change");
virObjectUnlock(vm);
-cleanup:
if (event)
qemuDomainEventQueue(driver, event);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
virDomainEventPtr event = NULL;
virDomainEventPtr lifecycleEvent = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- virCapsPtr caps = NULL;
-
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto cleanup;
virObjectLock(vm);
event = virDomainEventPMSuspendDiskNewFromObj(vm);
VIR_DOMAIN_EVENT_PMSUSPENDED,
VIR_DOMAIN_EVENT_PMSUSPENDED_DISK);
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after suspend event",
vm->def->name);
}
virObjectUnlock(vm);
-cleanup:
if (event)
qemuDomainEventQueue(driver, event);
if (lifecycleEvent)
qemuDomainEventQueue(driver, lifecycleEvent);
- virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
int state;
int reason;
virQEMUDriverConfigPtr cfg;
- virCapsPtr caps = NULL;
size_t i;
memcpy(&oldjob, &data->oldjob, sizeof(oldjob));
* deleted if qemuConnectMonitor() failed */
virObjectRef(obj);
- if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
- goto error;
-
/* XXX check PID liveliness & EXE path */
if (qemuConnectMonitor(driver, obj) < 0)
goto error;
goto error;
/* update domain state XML with possibly updated state in virDomainObj */
- if (virDomainSaveStatus(caps, cfg->stateDir, obj) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, obj) < 0)
goto error;
/* Run an hook to allow admins to do some magic */
virConnectClose(conn);
virObjectUnref(cfg);
- virObjectUnref(caps);
return;
}
}
virConnectClose(conn);
- virObjectUnref(caps);
virObjectUnref(cfg);
}
* report implicit runtime defaults in the XML, like vnc listen/socket
*/
VIR_DEBUG("Setting current domain def as transient");
- if (virDomainObjSetDefTransient(caps, vm, true) < 0)
+ if (virDomainObjSetDefTransient(caps, driver->xmlconf, vm, true) < 0)
goto cleanup;
vm->def->id = qemuDriverAllocateID(driver);
}
VIR_DEBUG("Writing early domain status to disk");
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0) {
goto cleanup;
}
goto cleanup;
VIR_DEBUG("Writing domain status to disk");
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
goto cleanup;
/* finally we can call the 'started' hook script if any */
* report implicit runtime defaults in the XML, like vnc listen/socket
*/
VIR_DEBUG("Setting current domain def as transient");
- if (virDomainObjSetDefTransient(caps, vm, true) < 0)
+ if (virDomainObjSetDefTransient(caps, driver->xmlconf, vm, true) < 0)
goto cleanup;
vm->def->id = qemuDriverAllocateID(driver);
virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, reason);
VIR_DEBUG("Writing domain status to disk");
- if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(driver->xmlconf, cfg->stateDir, vm) < 0)
goto cleanup;
/* Run an hook to allow admins to do some magic */
char *files; /* list of files */
virDomainDefPtr def; /* VM definition */
virCapsPtr caps; /* VM capabilities */
+ virDomainXMLConfPtr xmlconf;/* XML parser data */
char *hvm; /* type of hypervisor (eg hvm, xen) */
virArch arch; /* machine architecture */
char *newfile; /* newly added file */
VIR_FREE(ctl->def);
virObjectUnref(ctl->caps);
+ virObjectUnref(ctl->xmlconf);
VIR_FREE(ctl->files);
VIR_FREE(ctl->hvm);
VIR_FREE(ctl->newfile);
goto exit;
}
+ if (!(ctl->xmlconf = virDomainXMLConfNew(NULL, NULL))) {
+ vah_error(ctl, 0, _("Failed to create XML config object"));
+ goto exit;
+ }
+
ctl->caps->defaultConsoleTargetType = aaDefaultConsoleType;
if ((guest = virCapabilitiesAddGuest(ctl->caps,
goto exit;
}
- ctl->def = virDomainDefParseString(ctl->caps, xmlStr, -1,
+ ctl->def = virDomainDefParseString(ctl->caps, ctl->xmlconf,
+ xmlStr, -1,
VIR_DOMAIN_XML_INACTIVE);
if (ctl->def == NULL) {
vah_error(ctl, 0, _("could not parse XML"));
char *path;
int nextDomID;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
virNodeInfo nodeInfo;
virDomainObjListPtr domains;
virNetworkObjList networks;
return VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL;
}
+
+static virDomainXMLConfPtr
+testBuildXMLConfig(void)
+{
+ virDomainXMLPrivateDataCallbacks priv = { .alloc = testDomainObjPrivateAlloc,
+ .free = testDomainObjPrivateFree };
+ return virDomainXMLConfNew(&priv, NULL);
+}
+
+
static virCapsPtr
testBuildCapabilities(virConnectPtr conn) {
testConnPtr privconn = conn->privateData;
goto no_memory;
}
- caps->privateDataAllocFunc = testDomainObjPrivateAlloc;
- caps->privateDataFreeFunc = testDomainObjPrivateFree;
-
caps->host.nsecModels = 1;
if (VIR_ALLOC_N(caps->host.secModels, caps->host.nsecModels) < 0)
goto no_memory;
virDomainObjSetState(dom, VIR_DOMAIN_RUNNING, reason);
dom->def->id = privconn->nextDomID++;
- if (virDomainObjSetDefTransient(privconn->caps, dom, false) < 0) {
+ if (virDomainObjSetDefTransient(privconn->caps,
+ privconn->xmlconf,
+ dom, false) < 0) {
goto cleanup;
}
if (!(privconn->caps = testBuildCapabilities(conn)))
goto error;
+ if (!(privconn->xmlconf = testBuildXMLConfig()))
+ goto error;
+
privconn->nextDomID = 1;
- if (!(domdef = virDomainDefParseString(privconn->caps, defaultDomainXML,
+ if (!(domdef = virDomainDefParseString(privconn->caps,
+ privconn->xmlconf,
+ defaultDomainXML,
1 << VIR_DOMAIN_VIRT_TEST,
VIR_DOMAIN_XML_INACTIVE)))
goto error;
if (testDomainGenerateIfnames(domdef) < 0)
goto error;
if (!(domobj = virDomainObjListAdd(privconn->domains,
- privconn->caps,
+ privconn->xmlconf,
domdef, 0, NULL)))
goto error;
domdef = NULL;
if (!(privconn->caps = testBuildCapabilities(conn)))
goto error;
+ if (!(privconn->xmlconf = testBuildXMLConfig()))
+ goto error;
+
if (!(xml = virXMLParseFileCtxt(file, &ctxt))) {
goto error;
}
_("resolving domain filename"));
goto error;
}
- def = virDomainDefParseFile(privconn->caps, absFile,
+ def = virDomainDefParseFile(privconn->caps,
+ privconn->xmlconf, absFile,
1 << VIR_DOMAIN_VIRT_TEST,
VIR_DOMAIN_XML_INACTIVE);
VIR_FREE(absFile);
if (!def)
goto error;
} else {
- if ((def = virDomainDefParseNode(privconn->caps, xml, domains[i],
+ if ((def = virDomainDefParseNode(privconn->caps, privconn->xmlconf,
+ xml, domains[i],
1 << VIR_DOMAIN_VIRT_TEST,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto error;
if (testDomainGenerateIfnames(def) < 0 ||
!(dom = virDomainObjListAdd(privconn->domains,
- privconn->caps,
+ privconn->xmlconf,
def, 0, NULL))) {
virDomainDefFree(def);
goto error;
testConnPtr privconn = conn->privateData;
testDriverLock(privconn);
virObjectUnref(privconn->caps);
+ virObjectUnref(privconn->xmlconf);
virObjectUnref(privconn->domains);
virNodeDeviceObjListFree(&privconn->devs);
virNetworkObjListFree(&privconn->networks);
virCheckFlags(0, NULL);
testDriverLock(privconn);
- if ((def = virDomainDefParseString(privconn->caps, xml,
- 1 << VIR_DOMAIN_VIRT_TEST,
+ if ((def = virDomainDefParseString(privconn->caps, privconn->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_TEST,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
if (testDomainGenerateIfnames(def) < 0)
goto cleanup;
if (!(dom = virDomainObjListAdd(privconn->domains,
- privconn->caps,
+ privconn->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
}
xml[len] = '\0';
- def = virDomainDefParseString(privconn->caps, xml,
- 1 << VIR_DOMAIN_VIRT_TEST,
+ def = virDomainDefParseString(privconn->caps, privconn->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_TEST,
VIR_DOMAIN_XML_INACTIVE);
if (!def)
goto cleanup;
if (testDomainGenerateIfnames(def) < 0)
goto cleanup;
if (!(dom = virDomainObjListAdd(privconn->domains,
- privconn->caps,
+ privconn->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(privconn->caps, vm, &flags, &def) < 0)
+ if (virDomainLiveConfigHelperMethod(privconn->caps, privconn->xmlconf,
+ vm, &flags, &def) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE)
}
if (!(persistentDef = virDomainObjGetPersistentDef(privconn->caps,
+ privconn->xmlconf,
privdom)))
goto cleanup;
virDomainDefPtr oldDef = NULL;
testDriverLock(privconn);
- if ((def = virDomainDefParseString(privconn->caps, xml,
- 1 << VIR_DOMAIN_VIRT_TEST,
+ if ((def = virDomainDefParseString(privconn->caps, privconn->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_TEST,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
if (testDomainGenerateIfnames(def) < 0)
goto cleanup;
if (!(dom = virDomainObjListAdd(privconn->domains,
- privconn->caps,
+ privconn->xmlconf,
def,
0,
&oldDef)))
int inotifyWatch;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
/* Event handling */
virDomainEventStatePtr domainEventState;
char *base = NULL;
char *userdir = NULL;
+ virDomainXMLPrivateDataCallbacks privcb = {
+ .alloc = umlDomainObjPrivateAlloc,
+ .free = umlDomainObjPrivateFree,
+ };
+
if (VIR_ALLOC(uml_driver) < 0)
return -1;
if ((uml_driver->caps = umlCapsInit()) == NULL)
goto out_of_memory;
- uml_driver->caps->privateDataAllocFunc = umlDomainObjPrivateAlloc;
- uml_driver->caps->privateDataFreeFunc = umlDomainObjPrivateFree;
+ if (!(uml_driver->xmlconf = virDomainXMLConfNew(&privcb,
+ NULL)))
+ goto error;
if ((uml_driver->inotifyFD = inotify_init()) < 0) {
VIR_ERROR(_("cannot initialize inotify"));
if (virDomainObjListLoadAllConfigs(uml_driver->domains,
uml_driver->caps,
+ uml_driver->xmlconf,
uml_driver->configDir,
uml_driver->autostartDir,
0, 1 << VIR_DOMAIN_VIRT_UML,
umlDriverLock(uml_driver);
virDomainObjListLoadAllConfigs(uml_driver->domains,
uml_driver->caps,
+ uml_driver->xmlconf,
uml_driver->configDir,
uml_driver->autostartDir,
0, 1 << VIR_DOMAIN_VIRT_UML,
* report implicit runtime defaults in the XML, like vnc listen/socket
*/
VIR_DEBUG("Setting current domain def as transient");
- if (virDomainObjSetDefTransient(driver->caps, vm, true) < 0) {
+ if (virDomainObjSetDefTransient(driver->caps, driver->xmlconf,
+ vm, true) < 0) {
VIR_FORCE_CLOSE(logfd);
return -1;
}
(ret = umlProcessAutoDestroyAdd(driver, vm, conn)) < 0)
goto cleanup;
- ret = virDomainObjSetDefTransient(driver->caps, vm, false);
+ ret = virDomainObjSetDefTransient(driver->caps, driver->xmlconf, vm, false);
cleanup:
VIR_FORCE_CLOSE(logfd);
virCommandFree(cmd);
virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, NULL);
umlDriverLock(driver);
- if (!(def = virDomainDefParseString(driver->caps, xml,
- 1 << VIR_DOMAIN_VIRT_UML,
+ if (!(def = virDomainDefParseString(driver->caps, driver->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_UML,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
def,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
virDomainPtr dom = NULL;
umlDriverLock(driver);
- if (!(def = virDomainDefParseString(driver->caps, xml,
- 1 << VIR_DOMAIN_VIRT_UML,
+ if (!(def = virDomainDefParseString(driver->caps, driver->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_UML,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
def,
0, NULL)))
goto cleanup;
unsigned long version;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
IVirtualBox *vboxObj;
ISession *vboxSession;
}
+static virDomainXMLConfPtr
+vboxXMLConfInit(void)
+{
+ return virDomainXMLConfNew(NULL, NULL);
+}
+
+
static virCapsPtr vboxCapsInit(void)
{
virCapsPtr caps;
data->pFuncs->pfnComUninitialize();
virObjectUnref(data->caps);
+ virObjectUnref(data->xmlconf);
#if VBOX_API_VERSION == 2002
/* No domainEventCallbacks in 2.2.* version */
#else /* !(VBOX_API_VERSION == 2002) */
if (!(data->caps = vboxCapsInit()) ||
vboxInitialize(data) < 0 ||
- vboxExtractVersion(data) < 0) {
+ vboxExtractVersion(data) < 0 ||
+ !(data->xmlconf = vboxXMLConfInit())) {
vboxUninitialize(data);
return VIR_DRV_OPEN_ERROR;
}
#endif
nsresult rc;
- if (!(def = virDomainDefParseString(data->caps, xml,
- 1 << VIR_DOMAIN_VIRT_VBOX,
+ if (!(def = virDomainDefParseString(data->caps, data->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_VBOX,
VIR_DOMAIN_XML_INACTIVE))) {
goto cleanup;
}
/* VBox has no snapshot metadata, so this flag is trivial. */
virCheckFlags(VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA, NULL);
- if (!(def = virDomainSnapshotDefParseString(xmlDesc, NULL, 0, 0)))
+ if (!(def = virDomainSnapshotDefParseString(xmlDesc, data->caps,
+ data->xmlconf, 0, 0)))
goto cleanup;
if (def->ndisks) {
virMutexDestroy(&driver->lock);
virObjectUnref(driver->domains);
virObjectUnref(driver->caps);
+ virObjectUnref(driver->xmlconf);
VIR_FREE(driver);
}
}
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
vmdef, 0, NULL)))
goto cleanup;
struct vmware_driver {
virMutex lock;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
virDomainObjListPtr domains;
int version;
VIR_FREE(dom);
}
+static virDomainXMLConfPtr
+vmwareDomainXMLConfigInit(void)
+{
+ virDomainXMLPrivateDataCallbacks priv = { .alloc = vmwareDataAllocFunc,
+ .free = vmwareDataFreeFunc };
+
+ return virDomainXMLConfNew(&priv, NULL);
+}
+
static virDrvOpenStatus
vmwareOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
if (!(driver->caps = vmwareCapsInit()))
goto cleanup;
- driver->caps->privateDataAllocFunc = vmwareDataAllocFunc;
- driver->caps->privateDataFreeFunc = vmwareDataFreeFunc;
+ if (!(driver->xmlconf = vmwareDomainXMLConfigInit()))
+ goto cleanup;
if (vmwareLoadDomains(driver) < 0)
goto cleanup;
ctx.formatFileName = vmwareCopyVMXFileName;
vmwareDriverLock(driver);
- if ((vmdef = virDomainDefParseString(driver->caps, xml,
- 1 << VIR_DOMAIN_VIRT_VMWARE,
+ if ((vmdef = virDomainDefParseString(driver->caps, driver->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_VMWARE,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
/* assign def */
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
vmdef,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
vmwareDriverLock(driver);
- if ((vmdef = virDomainDefParseString(driver->caps, xml,
- 1 << VIR_DOMAIN_VIRT_VMWARE,
+ if ((vmdef = virDomainDefParseString(driver->caps, driver->xmlconf,
+ xml, 1 << VIR_DOMAIN_VIRT_VMWARE,
VIR_DOMAIN_XML_INACTIVE)) == NULL)
goto cleanup;
/* assign def */
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ driver->xmlconf,
vmdef,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
goto fail;
}
+ if (!(priv->xmlconf = virDomainXMLConfNew(NULL, NULL)))
+ goto fail;
+
#if WITH_XEN_INOTIFY
if (xenHavePrivilege()) {
VIR_DEBUG("Trying Xen inotify sub-driver");
int i;
virObjectUnref(priv->caps);
+ virObjectUnref(priv->xmlconf);
virDomainEventStateFree(priv->domainEvents);
for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i)
goto cleanup;
}
- if (!(def = virDomainDefParseString(priv->caps, xmlData,
- 1 << VIR_DOMAIN_VIRT_XEN, 0)))
+ if (!(def = virDomainDefParseString(priv->caps, priv->xmlconf,
+ xmlData, 1 << VIR_DOMAIN_VIRT_XEN, 0)))
goto cleanup;
if (STREQ(format, XEN_CONFIG_FORMAT_XM)) {
* holding the lock
*/
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
int handle; /* Xen hypervisor handle */
int xendConfigVersion; /* XenD config version */
virCheckFlags(0, NULL);
- if (!(def = virDomainDefParseString(priv->caps, xmlDesc,
- 1 << VIR_DOMAIN_VIRT_XEN,
+ if (!(def = virDomainDefParseString(priv->caps, priv->xmlconf,
+ xmlDesc, 1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE)))
return NULL;
if (priv->xendConfigVersion < XEND_CONFIG_VERSION_3_0_4)
return NULL;
- if (!(def = virDomainDefParseString(priv->caps, xmlDesc,
- 1 << VIR_DOMAIN_VIRT_XEN,
+ if (!(def = virDomainDefParseString(priv->caps, priv->xmlconf,
+ xmlDesc, 1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE))) {
virReportError(VIR_ERR_XML_ERROR,
"%s", _("failed to parse domain description"));
return NULL;
}
- if (!(def = virDomainDefParseString(priv->caps, xml,
+ if (!(def = virDomainDefParseString(priv->caps, priv->xmlconf, xml,
1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE))) {
xenUnifiedUnlock(priv);
goto error;
}
+ if (!(privP->xmlconf = virDomainXMLConfNew(NULL, NULL))) {
+ xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
+ _("Failed to create XML conf object"));
+ goto error;
+ }
+
xmlInitParser();
xmlKeepBlanksDefault(0);
xen_init();
if (privP != NULL) {
virObjectUnref(privP->caps);
+ virObjectUnref(privP->xmlconf);
if (privP->session != NULL)
xenSessionFree(privP->session);
struct _xenapiPrivate *priv = conn->privateData;
virObjectUnref(priv->caps);
+ virObjectUnref(priv->xmlconf);
if (priv->session != NULL) {
xen_session_logout(priv->session);
static char *
xenapiGetCapabilities(virConnectPtr conn)
{
+
virCapsPtr caps = ((struct _xenapiPrivate *)(conn->privateData))->caps;
if (caps) {
char *xml = virCapabilitiesFormatXML(caps);
const char *xmlDesc,
unsigned int flags)
{
+ struct _xenapiPrivate *priv = conn->privateData;
xen_vm_record *record = NULL;
xen_vm vm = NULL;
virDomainPtr domP = NULL;
- xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
- virCapsPtr caps = ((struct _xenapiPrivate *)(conn->privateData))->caps;
- if (!caps)
+ if (!priv->caps)
return NULL;
virCheckFlags(0, NULL);
- virDomainDefPtr defPtr = virDomainDefParseString(caps, xmlDesc,
+ virDomainDefPtr defPtr = virDomainDefParseString(priv->caps, priv->xmlconf,
+ xmlDesc,
1 << VIR_DOMAIN_VIRT_XEN,
flags);
createVMRecordFromXml(conn, defPtr, &record, &vm);
unsigned char raw_uuid[VIR_UUID_BUFLEN];
ignore_value(virUUIDParse(record->uuid, raw_uuid));
if (vm) {
- if (xen_vm_start(session, vm, false, false)) {
+ if (xen_vm_start(priv->session, vm, false, false)) {
domP = virGetDomain(conn, record->name_label, raw_uuid);
if (!domP) {
xen_vm_record_free(record);
static virDomainPtr
xenapiDomainDefineXML(virConnectPtr conn, const char *xml)
{
+ struct _xenapiPrivate *priv = conn->privateData;
xen_vm_record *record=NULL;
xen_vm vm=NULL;
virDomainPtr domP=NULL;
- xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
- virCapsPtr caps = ((struct _xenapiPrivate *)(conn->privateData))->caps;
- if (!caps)
+ if (!priv->caps)
return NULL;
- virDomainDefPtr defPtr = virDomainDefParseString(caps, xml,
- 1 << VIR_DOMAIN_VIRT_XEN, 0);
+ virDomainDefPtr defPtr = virDomainDefParseString(priv->caps, priv->xmlconf,
+ xml,
+ 1 << VIR_DOMAIN_VIRT_XEN,
+ 0);
if (!defPtr)
return NULL;
if (createVMRecordFromXml(conn, defPtr, &record, &vm) != 0) {
- if (!session->ok)
+ if (!priv->session->ok)
xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
else
xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
unsigned char raw_uuid[VIR_UUID_BUFLEN];
ignore_value(virUUIDParse(record->uuid, raw_uuid));
domP = virGetDomain(conn, record->name_label, raw_uuid);
- if (!domP && !session->ok)
+ if (!domP && !priv->session->ok)
xenapiSessionErrorHandler(conn, VIR_ERR_NO_DOMAIN, NULL);
xen_vm_record_free(record);
}
char *url;
int noVerify;
virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
};
#endif /* __VIR_XENAPI_H__ */
if (internal)
flags |= VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL;
if (!(def = virDomainSnapshotDefParseString(inXmlData, driver.caps,
+ driver.xmlconf,
QEMU_EXPECTED_VIRT_TYPES,
flags)))
goto fail;
if ((driver.caps = testQemuCapsInit()) == NULL)
return EXIT_FAILURE;
+ if (!(driver.xmlconf = virQEMUDriverCreateXMLConf()))
+ return EXIT_FAILURE;
+
# define DO_TEST(name, uuid, internal) \
do { \
const struct testInfo info = {name, uuid, internal}; \
DO_TEST("external_vm", "c7a5fdbd-edaf-9455-926a-d65c16db1809", 0);
virObjectUnref(driver.caps);
+ virObjectUnref(driver.xmlconf);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
# include "testutilslxc.h"
static virCapsPtr caps;
+static virDomainXMLConfPtr xmlconf;
static int
testCompareXMLToXMLFiles(const char *inxml, const char *outxml, bool live)
if (virtTestLoadFile(outxml, &outXmlData) < 0)
goto fail;
- if (!(def = virDomainDefParseString(caps, inXmlData,
+ if (!(def = virDomainDefParseString(caps, xmlconf, inXmlData,
1 << VIR_DOMAIN_VIRT_LXC,
live ? 0 : VIR_DOMAIN_XML_INACTIVE)))
goto fail;
if ((caps = testLXCCapsInit()) == NULL)
return EXIT_FAILURE;
+ if (!(xmlconf = lxcDomainXMLConfInit()))
+ return EXIT_FAILURE;
+
# define DO_TEST_FULL(name, is_different, inactive) \
do { \
const struct testInfo info = {name, is_different, inactive}; \
DO_TEST("hostdev");
virObjectUnref(caps);
+ virObjectUnref(xmlconf);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
if (virtTestLoadFile(xml, &expectxml) < 0)
goto fail;
- if (!(vmdef = qemuParseCommandLineString(driver.caps, cmd,
- NULL, NULL, NULL)))
+ if (!(vmdef = qemuParseCommandLineString(driver.caps, driver.xmlconf,
+ cmd, NULL, NULL, NULL)))
goto fail;
if ((log = virtTestLogContentAndReset()) == NULL)
if ((driver.caps = testQemuCapsInit()) == NULL)
return EXIT_FAILURE;
+ if (!(driver.xmlconf = virQEMUDriverCreateXMLConf()))
+ return EXIT_FAILURE;
+
# define DO_TEST_FULL(name, extraFlags, migrateFrom) \
do { \
const struct testInfo info = { name, extraFlags, migrateFrom }; \
virObjectUnref(driver.config);
virObjectUnref(driver.caps);
+ virObjectUnref(driver.xmlconf);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
#include "testutils.h"
#include "testutilsqemu.h"
#include "qemumonitortestutils.h"
+#include "qemu/qemu_conf.h"
#include "virthread.h"
#include "virerror.h"
static int
testQemuMonitorJSONGetStatus(const void *data)
{
- virCapsPtr caps = (virCapsPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
+ virDomainXMLConfPtr xmlconf = (virDomainXMLConfPtr)data;
+ qemuMonitorTestPtr test = qemuMonitorTestNew(true, xmlconf);
int ret = -1;
bool running = false;
virDomainPausedReason reason = 0;
static int
testQemuMonitorJSONGetVersion(const void *data)
{
- virCapsPtr caps = (virCapsPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
+ virDomainXMLConfPtr xmlconf = (virDomainXMLConfPtr)data;
+ qemuMonitorTestPtr test = qemuMonitorTestNew(true, xmlconf);
int ret = -1;
int major;
int minor;
static int
testQemuMonitorJSONGetMachines(const void *data)
{
- virCapsPtr caps = (virCapsPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
+ virDomainXMLConfPtr xmlconf = (virDomainXMLConfPtr)data;
+ qemuMonitorTestPtr test = qemuMonitorTestNew(true, xmlconf);
int ret = -1;
qemuMonitorMachineInfoPtr *info;
int ninfo = 0;
static int
testQemuMonitorJSONGetCPUDefinitions(const void *data)
{
- virCapsPtr caps = (virCapsPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
+ virDomainXMLConfPtr xmlconf = (virDomainXMLConfPtr)data;
+ qemuMonitorTestPtr test = qemuMonitorTestNew(true, xmlconf);
int ret = -1;
char **cpus = NULL;
int ncpus = 0;
static int
testQemuMonitorJSONGetCommands(const void *data)
{
- virCapsPtr caps = (virCapsPtr)data;
- qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
+ virDomainXMLConfPtr xmlconf = (virDomainXMLConfPtr)data;
+ qemuMonitorTestPtr test = qemuMonitorTestNew(true, xmlconf);
int ret = -1;
char **commands = NULL;
int ncommands = 0;
mymain(void)
{
int ret = 0;
- virCapsPtr caps;
+ virDomainXMLConfPtr xmlconf;
#if !WITH_YAJL
fputs("libvirt not compiled with yajl, skipping this test\n", stderr);
#endif
if (virThreadInitialize() < 0 ||
- !(caps = testQemuCapsInit()))
+ !(xmlconf = virQEMUDriverCreateXMLConf()))
return EXIT_FAILURE;
virEventRegisterDefaultImpl();
#define DO_TEST(name) \
- if (virtTestRun(# name, 1, testQemuMonitorJSON ## name, caps) < 0) \
+ if (virtTestRun(# name, 1, testQemuMonitorJSON ## name, xmlconf) < 0) \
ret = -1
DO_TEST(GetStatus);
DO_TEST(GetCPUDefinitions);
DO_TEST(GetCommands);
- virObjectUnref(caps);
+ virObjectUnref(xmlconf);
return (ret == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
#define QEMU_TEXT_GREETING "QEMU 1.0,1 monitor - type 'help' for more information"
-qemuMonitorTestPtr qemuMonitorTestNew(bool json, virCapsPtr caps)
+qemuMonitorTestPtr qemuMonitorTestNew(bool json, virDomainXMLConfPtr xmlconf)
{
qemuMonitorTestPtr test = NULL;
virDomainChrSourceDef src;
goto no_memory;
test->json = json;
- if (!(test->vm = virDomainObjNew(caps)))
+ if (!(test->vm = virDomainObjNew(xmlconf)))
goto error;
if (virNetSocketNewListenUNIX(path,
#ifndef __VIR_QEMU_MONITOR_TEST_UTILS_H__
# define __VIR_QEMU_MONITOR_TEST_UTILS_H__
-# include "capabilities.h"
+# include "domain_conf.h"
# include "qemu/qemu_monitor.h"
typedef struct _qemuMonitorTest qemuMonitorTest;
const char *response);
qemuMonitorTestPtr qemuMonitorTestNew(bool json,
- virCapsPtr caps);
+ virDomainXMLConfPtr xmlconf);
+
void qemuMonitorTestFree(qemuMonitorTestPtr test);
goto out;
conn->secretDriver = &fakeSecretDriver;
- if (!(vmdef = virDomainDefParseFile(driver.caps, xml,
+ if (!(vmdef = virDomainDefParseFile(driver.caps, driver.xmlconf, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE))) {
if (flags & FLAG_EXPECT_PARSE_ERROR)
if ((driver.caps = testQemuCapsInit()) == NULL)
return EXIT_FAILURE;
+ if (!(driver.xmlconf = virQEMUDriverCreateXMLConf()))
+ return EXIT_FAILURE;
VIR_FREE(driver.config->stateDir);
if ((driver.config->stateDir = strdup("/nowhere")) == NULL)
return EXIT_FAILURE;
virObjectUnref(driver.config);
virObjectUnref(driver.caps);
+ virObjectUnref(driver.xmlconf);
VIR_FREE(map);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
if (virtTestLoadFile(outxml, &outXmlData) < 0)
goto fail;
- if (!(def = virDomainDefParseString(driver.caps, inXmlData,
+ if (!(def = virDomainDefParseString(driver.caps, driver.xmlconf, inXmlData,
QEMU_EXPECTED_VIRT_TYPES,
live ? 0 : VIR_DOMAIN_XML_INACTIVE)))
goto fail;
if ((driver.caps = testQemuCapsInit()) == NULL)
return EXIT_FAILURE;
+ if (!(driver.xmlconf = virQEMUDriverCreateXMLConf()))
+ return EXIT_FAILURE;
+
# define DO_TEST_FULL(name, is_different, when) \
do { \
const struct testInfo info = {name, is_different, when}; \
DO_TEST_DIFFERENT("metadata");
virObjectUnref(driver.caps);
+ virObjectUnref(driver.xmlconf);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
if (len && expectargv[len - 1] == '\n')
expectargv[len - 1] = '\0';
- if (!(vmdef = virDomainDefParseFile(driver.caps, xml,
+ if (!(vmdef = virDomainDefParseFile(driver.caps, driver.xmlconf, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto fail;
driver.config = virQEMUDriverConfigNew(false);
if ((driver.caps = testQemuCapsInit()) == NULL)
return EXIT_FAILURE;
+ if (!(driver.xmlconf = virQEMUDriverCreateXMLConf()))
+ return EXIT_FAILURE;
if (virAsprintf(&map, "%s/src/cpu/cpu_map.xml", abs_top_srcdir) < 0 ||
cpuMapOverride(map) < 0) {
VIR_FREE(map);
virObjectUnref(driver.config);
virObjectUnref(driver.caps);
+ virObjectUnref(driver.xmlconf);
VIR_FREE(map);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
#define VIR_FROM_THIS VIR_FROM_NONE
static virCapsPtr caps;
+static virDomainXMLConfPtr xmlconf;
static virSecurityManagerPtr mgr;
goto cleanup;
}
- if (!(def = virDomainDefParseString(caps, xmlstr,
+ if (!(def = virDomainDefParseString(caps, xmlconf, xmlstr,
QEMU_EXPECTED_VIRT_TYPES,
0)))
goto cleanup;
if ((caps = testQemuCapsInit()) == NULL)
return EXIT_FAILURE;
+ if (!(xmlconf = virQEMUDriverCreateXMLConf()))
+ return EXIT_FAILURE;
+
#define DO_TEST_LABELING(name) \
if (virtTestRun("Labelling " # name, 1, testSELinuxLabeling, name) < 0) \
ret = -1; \
return -1;
}
+
virCapsPtr testQemuCapsInit(void) {
virCapsPtr caps;
virCapsGuestPtr guest;
(machines = testQemuAllocMachines(&nmachines)) == NULL)
goto cleanup;
- qemuDomainSetNamespaceHooks(caps);
-
if ((guest = virCapabilitiesAddGuest(caps, "hvm", VIR_ARCH_I686,
"/usr/bin/qemu", NULL,
nmachines, machines)) == NULL ||
#include "capabilities.h"
+#include "domain_conf.h"
virCapsPtr testQemuCapsInit(void);
+virDomainXMLConfPtr testQemuXMLConfInit(void);
return VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_XEN;
}
+virDomainXMLConfPtr
+testXenXMLConfInit(void)
+{
+ return virDomainXMLConfNew(NULL, NULL);
+}
+
virCapsPtr testXenCapsInit(void) {
struct utsname utsname;
virCapsPtr caps;
#include "capabilities.h"
+#include "domain_conf.h"
virCapsPtr testXenCapsInit(void);
+virDomainXMLConfPtr testXenXMLConfInit(void);
#include "viralloc.h"
static virCapsPtr caps;
+static virDomainXMLConfPtr xmlconf;
static int
testCompareParseXML(const char *xmcfg, const char *xml, int xendConfigVersion)
priv.caps = caps;
conn->privateData = &priv;
- if (!(def = virDomainDefParseString(caps, xmlData, 1 << VIR_DOMAIN_VIRT_XEN,
+ if (!(def = virDomainDefParseString(caps, xmlconf, xmlData,
+ 1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE)))
goto fail;
if (!(caps = testXenCapsInit()))
return EXIT_FAILURE;
+ if (!(xmlconf = testXenXMLConfInit()))
+ return EXIT_FAILURE;
+
#define DO_TEST(name, version) \
do { \
struct testInfo info0 = { name, version, 0 }; \
DO_TEST("pci-devs", 2);
virObjectUnref(caps);
+ virObjectUnref(xmlconf);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
#include "testutilsxen.h"
static virCapsPtr caps;
+static virDomainXMLConfPtr xmlconf;
static int
testCompareFiles(const char *xml, const char *sexpr, int xendConfigVersion)
if (virtTestLoadFile(sexpr, &sexprData) < 0)
goto fail;
- if (!(def = virDomainDefParseString(caps, xmlData, 1 << VIR_DOMAIN_VIRT_XEN,
+ if (!(def = virDomainDefParseString(caps, xmlconf, xmlData,
+ 1 << VIR_DOMAIN_VIRT_XEN,
VIR_DOMAIN_XML_INACTIVE)))
goto fail;
if (!(caps = testXenCapsInit()))
return EXIT_FAILURE;
+ if (!(xmlconf = testXenXMLConfInit()))
+ return EXIT_FAILURE;
+
DO_TEST("pv", "pv", "pvtest", 1);
DO_TEST("fv", "fv", "fvtest", 1);
DO_TEST("pv", "pv", "pvtest", 2);
DO_TEST("escape", "escape", "fvtest", 1);
virObjectUnref(caps);
+ virObjectUnref(xmlconf);
return ret==0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
static virCapsPtr caps;
static virVMXContext ctx;
+static virDomainXMLConfPtr xmlconf;
static int testDefaultConsoleType(const char *ostype ATTRIBUTE_UNUSED,
virArch arch ATTRIBUTE_UNUSED)
failure:
virObjectUnref(caps);
+ virObjectUnref(xmlconf);
caps = NULL;
}
goto failure;
}
- def = virDomainDefParseString(caps, xmlData, 1 << VIR_DOMAIN_VIRT_VMWARE,
+ def = virDomainDefParseString(caps, xmlconf, xmlData,
+ 1 << VIR_DOMAIN_VIRT_VMWARE,
VIR_DOMAIN_XML_INACTIVE);
if (def == NULL) {
return EXIT_FAILURE;
}
+ if (!(xmlconf = virDomainXMLConfNew(NULL, NULL)))
+ return EXIT_FAILURE;
+
ctx.opaque = NULL;
ctx.parseFileName = NULL;
ctx.formatFileName = testFormatVMXFileName;
projects / people / liuw / libxenctrl-split / libvirt.git / commitdiff