}
-static virCapsPtr
-qemuCreateCapabilities(virQEMUDriverPtr driver)
-{
- size_t i;
- virCapsPtr caps;
- virSecurityManagerPtr *sec_managers = NULL;
- /* Security driver data */
- const char *doi, *model;
- virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
-
- /* Basic host arch / guest machine capabilities */
- if (!(caps = virQEMUCapsInit(driver->qemuCapsCache))) {
- virReportOOMError();
- virObjectUnref(cfg);
- return NULL;
- }
-
- if (cfg->allowDiskFormatProbing) {
- caps->defaultDiskDriverName = NULL;
- caps->defaultDiskDriverType = VIR_STORAGE_FILE_AUTO;
- } else {
- caps->defaultDiskDriverName = "qemu";
- 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"));
- goto err_exit;
- }
-
- /* access sec drivers and create a sec model for each one */
- sec_managers = virSecurityManagerGetNested(driver->securityManager);
- if (sec_managers == NULL) {
- goto err_exit;
- }
-
- /* calculate length */
- for (i = 0; sec_managers[i]; i++)
- ;
- caps->host.nsecModels = i;
-
- if (VIR_ALLOC_N(caps->host.secModels, caps->host.nsecModels) < 0)
- goto no_memory;
-
- for (i = 0; sec_managers[i]; i++) {
- doi = virSecurityManagerGetDOI(sec_managers[i]);
- model = virSecurityManagerGetModel(sec_managers[i]);
- if (!(caps->host.secModels[i].model = strdup(model)))
- goto no_memory;
- if (!(caps->host.secModels[i].doi = strdup(doi)))
- goto no_memory;
- VIR_DEBUG("Initialized caps for security driver \"%s\" with "
- "DOI \"%s\"", model, doi);
- }
- VIR_FREE(sec_managers);
-
- virObjectUnref(cfg);
- return caps;
-
-no_memory:
- virReportOOMError();
-err_exit:
- VIR_FREE(sec_managers);
- virObjectUnref(caps);
- virObjectUnref(cfg);
- return NULL;
-}
-
-
static int
qemuDomainSnapshotLoad(virDomainObjPtr vm,
void *data)
VIR_DOMAIN_SNAPSHOT_PARSE_DISKS |
VIR_DOMAIN_SNAPSHOT_PARSE_INTERNAL);
int ret = -1;
+ virCapsPtr caps = NULL;
virObjectLock(vm);
if (virAsprintf(&snapDir, "%s/%s", baseDir, vm->def->name) < 0) {
goto cleanup;
}
+ if (!(caps = virQEMUDriverGetCapabilities(qemu_driver, false)))
+ goto cleanup;
+
VIR_INFO("Scanning for snapshots for domain %s in %s", vm->def->name,
snapDir);
continue;
}
- def = virDomainSnapshotDefParseString(xmlStr, qemu_driver->caps,
+ def = virDomainSnapshotDefParseString(xmlStr, caps,
QEMU_EXPECTED_VIRT_TYPES,
flags);
if (def == NULL) {
if (dir)
closedir(dir);
VIR_FREE(snapDir);
+ virObjectUnref(caps);
virObjectUnlock(vm);
return ret;
}
if (!qemu_driver->qemuCapsCache)
goto error;
- if ((qemu_driver->caps = qemuCreateCapabilities(qemu_driver)) == NULL)
+ if ((qemu_driver->caps = virQEMUDriverCreateCapabilities(qemu_driver)) == NULL)
goto error;
/* If hugetlbfs is present, then we need to create a sub-directory within
*/
static int
qemuReload(void) {
- virQEMUDriverConfigPtr cfg;
+ virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
if (!qemu_driver)
return 0;
qemuDriverLock(qemu_driver);
+ if (!(caps = virQEMUDriverGetCapabilities(qemu_driver, false)))
+ goto cleanup;
+
cfg = virQEMUDriverGetConfig(qemu_driver);
virDomainObjListLoadAllConfigs(qemu_driver->domains,
- qemu_driver->caps,
+ caps,
cfg->configDir,
cfg->autostartDir,
0, QEMU_EXPECTED_VIRT_TYPES,
qemuNotifyLoadDomain, qemu_driver);
+
+cleanup:
qemuDriverUnlock(qemu_driver);
virObjectUnref(cfg);
+ virObjectUnref(caps);
return 0;
}
qemuDriverLock(driver);
- if ((caps = qemuCreateCapabilities(qemu_driver)) == NULL)
+ if (!(caps = virQEMUDriverGetCapabilities(qemu_driver, true)))
goto cleanup;
- virObjectUnref(qemu_driver->caps);
- qemu_driver->caps = caps;
-
- if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
+ if ((xml = virCapabilitiesFormatXML(caps)) == NULL)
virReportOOMError();
+ virObjectUnref(caps);
cleanup:
qemuDriverUnlock(driver);
virQEMUDriverPtr driver = conn->privateData;
int ret = -1;
unsigned int qemuVersion;
+ virCapsPtr caps = NULL;
qemuDriverLock(driver);
- if (virQEMUCapsGetDefaultVersion(driver->caps,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virQEMUCapsGetDefaultVersion(caps,
driver->qemuCapsCache,
&qemuVersion) < 0)
goto cleanup;
ret = 0;
cleanup:
+ virObjectUnref(caps);
qemuDriverUnlock(driver);
return ret;
}
static virDomainPtr qemuDomainCreate(virConnectPtr conn, const char *xml,
unsigned int flags) {
virQEMUDriverPtr driver = conn->privateData;
- virDomainDefPtr def;
+ virDomainDefPtr def = NULL;
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
virDomainEventPtr event = NULL;
virDomainEventPtr event2 = NULL;
unsigned int start_flags = VIR_QEMU_PROCESS_START_COLD;
virQEMUCapsPtr qemuCaps = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_START_PAUSED |
VIR_DOMAIN_START_AUTODESTROY, NULL);
start_flags |= VIR_QEMU_PROCESS_START_AUTODESROY;
qemuDriverLock(driver);
- if (!(def = virDomainDefParseString(driver->caps, xml,
+
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (!(def = virDomainDefParseString(caps, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ caps,
def,
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
NULL)))
if (event2)
qemuDomainEventQueue(driver, event2);
}
+ virObjectUnref(caps);
virObjectUnref(qemuCaps);
qemuDriverUnlock(driver);
return dom;
int eventDetail;
int state;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
eventDetail);
}
}
- if (virDomainSaveStatus(driver->caps, cfg->stateDir, vm) < 0)
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto endjob;
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
goto endjob;
ret = 0;
if (event)
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
virDomainEventPtr event = NULL;
int state;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
VIR_DOMAIN_EVENT_RESUMED,
VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);
}
- if (virDomainSaveStatus(driver->caps, cfg->stateDir, vm) < 0)
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto endjob;
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
goto endjob;
ret = 0;
if (event)
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
virDomainDefPtr persistentDef = NULL;
int ret = -1, r;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto endjob;
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto endjob;
cleanup:
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
int rc;
virDomainEventPtr event = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
+ virCapsPtr caps;
+
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
if (!qemuMigrationIsAllowed(driver, vm, vm->def, false))
goto cleanup;
if (xmlin) {
virDomainDefPtr def = NULL;
- if (!(def = virDomainDefParseString(driver->caps, xmlin,
+ if (!(def = virDomainDefParseString(caps, xmlin,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE))) {
goto endjob;
qemuDomainEventQueue(driver, event);
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
return ret;
}
unsigned int flags)
{
virQEMUDriverPtr driver = dom->conn->privateData;
- virDomainObjPtr vm;
+ virDomainObjPtr vm = NULL;
virDomainDefPtr persistentDef;
const char * type;
int max;
int ret = -1;
bool maximum;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
}
cfg = virQEMUDriverGetConfig(driver);
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
maximum = (flags & VIR_DOMAIN_VCPU_MAXIMUM) != 0;
flags &= ~VIR_DOMAIN_VCPU_MAXIMUM;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto endjob;
cleanup:
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
virDomainVcpuPinDefPtr *newVcpuPin = NULL;
virBitmapPtr pcpumap = NULL;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (newVcpuPin)
virDomainVcpuPinDefArrayFree(newVcpuPin, newVcpuPinNum);
- if (virDomainSaveStatus(driver->caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
goto cleanup;
}
if (vm)
virObjectUnlock(vm);
virBitmapFree(pcpumap);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
virBitmapPtr cpumask = NULL;
unsigned char *cpumap;
bool pinned;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&targetDef) < 0)
goto cleanup;
cleanup:
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
return ret;
}
virDomainVcpuPinDefPtr *newVcpuPin = NULL;
virBitmapPtr pcpumap = NULL;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
if (vm->def->placement_mode == VIR_DOMAIN_CPU_PLACEMENT_MODE_AUTO) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("Changing affinity for emulator thread dynamically "
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
goto cleanup;
}
- if (virDomainSaveStatus(driver->caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
goto cleanup;
}
if (cgroup_dom)
virCgroupFree(&cgroup_dom);
virBitmapFree(pcpumap);
-
+ virObjectUnref(caps);
if (vm)
virObjectUnlock(vm);
virObjectUnref(cfg);
int maxcpu, hostcpus, pcpu;
virBitmapPtr cpumask = NULL;
bool pinned;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&targetDef) < 0)
goto cleanup;
cleanup:
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
return ret;
}
virDomainObjPtr vm;
virDomainDefPtr def;
int ret = -1;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags, &def) < 0)
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags, &def) < 0)
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
cleanup:
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
return ret;
}
virQEMUDriverPtr driver = conn->privateData;
char *p;
int ret = 0;
+ virCapsPtr caps = NULL;
qemuDriverLock(driver);
memset(secmodel, 0, sizeof(*secmodel));
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
/* We treat no driver as success, but simply return no data in *secmodel */
- if (driver->caps->host.nsecModels == 0 ||
- driver->caps->host.secModels[0].model == NULL)
+ if (caps->host.nsecModels == 0 ||
+ caps->host.secModels[0].model == NULL)
goto cleanup;
- p = driver->caps->host.secModels[0].model;
+ p = caps->host.secModels[0].model;
if (strlen(p) >= VIR_SECURITY_MODEL_BUFLEN-1) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("security model string exceeds max %d bytes"),
}
strcpy(secmodel->model, p);
- p = driver->caps->host.secModels[0].doi;
+ p = caps->host.secModels[0].doi;
if (strlen(p) >= VIR_SECURITY_DOI_BUFLEN-1) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("security DOI string exceeds max %d bytes"),
cleanup:
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
return ret;
}
char *xml = NULL;
virDomainDefPtr def = NULL;
int oflags = edit ? O_RDWR : O_RDONLY;
+ virCapsPtr caps = NULL;
if (bypass_cache) {
int directFlag = virFileDirectFdFlag();
oflags |= directFlag;
}
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto error;
+
if ((fd = qemuOpenFile(driver, path, oflags, NULL, NULL)) < 0)
goto error;
if (bypass_cache &&
header.was_running = state;
/* Create a domain from this XML */
- if (!(def = virDomainDefParseString(driver->caps, xml,
+ if (!(def = virDomainDefParseString(caps, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto error;
if (xmlin) {
virDomainDefPtr def2 = NULL;
- if (!(def2 = virDomainDefParseString(driver->caps, xmlin,
+ if (!(def2 = virDomainDefParseString(caps, xmlin,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto error;
*ret_def = def;
*ret_header = header;
+ virObjectUnref(caps);
+
return fd;
error:
virDomainDefFree(def);
VIR_FREE(xml);
VIR_FORCE_CLOSE(fd);
+ virObjectUnref(caps);
return -1;
}
virCommandPtr cmd = NULL;
char *errbuf = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
+ virCapsPtr caps = NULL;
+
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
if (header->version == 2) {
const char *prog = qemuSaveCompressionTypeToString(header->compressed);
virReportError(VIR_ERR_OPERATION_FAILED,
_("Invalid compressed save format %d"),
header->compressed);
- goto out;
+ goto cleanup;
}
if (header->compressed != QEMU_SAVE_FORMAT_RAW) {
_("Failed to start decompression binary %s"),
prog);
*fd = intermediatefd;
- goto out;
+ goto cleanup;
}
}
}
if (ret < 0) {
virDomainAuditStart(vm, "restored", false);
- goto out;
+ goto cleanup;
}
event = virDomainEventNewFromObj(vm,
if (virGetLastError() == NULL)
virReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("failed to resume domain"));
- goto out;
+ goto cleanup;
}
- if (virDomainSaveStatus(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
VIR_WARN("Failed to save status on vm %s", vm->def->name);
- goto out;
+ goto cleanup;
}
} else {
int detail = (start_paused ? VIR_DOMAIN_EVENT_SUSPENDED_PAUSED :
ret = 0;
-out:
+cleanup:
virCommandFree(cmd);
VIR_FREE(errbuf);
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,
- driver->caps,
+ caps,
def,
VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
virFileWrapperFdFree(wrapperFd);
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
qemuDriverUnlock(driver);
return ret;
}
virQEMUDriverPtr driver = conn->privateData;
virDomainDefPtr def = NULL;
char *xml = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(0, NULL);
}
qemuDriverLock(driver);
- def = qemuParseCommandLineString(driver->caps, config,
+
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ def = qemuParseCommandLineString(caps, config,
NULL, NULL, NULL);
qemuDriverUnlock(driver);
if (!def)
cleanup:
virDomainDefFree(def);
+ virObjectUnref(caps);
return xml;
}
char *ret = NULL;
int i;
virQEMUDriverConfigPtr cfg;
+ virCapsPtr caps = NULL;
virCheckFlags(0, NULL);
goto cleanup;
}
- def = virDomainDefParseString(driver->caps, xmlData,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ def = virDomainDefParseString(caps, xmlData,
QEMU_EXPECTED_VIRT_TYPES, 0);
if (!def)
goto cleanup;
virObjectUnref(qemuCaps);
virCommandFree(cmd);
virDomainDefFree(def);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
static virDomainPtr qemuDomainDefine(virConnectPtr conn, const char *xml) {
virQEMUDriverPtr driver = conn->privateData;
- virDomainDefPtr def;
+ virDomainDefPtr def = NULL;
virDomainDefPtr oldDef = NULL;
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
virDomainEventPtr event = NULL;
virQEMUCapsPtr qemuCaps = NULL;
virQEMUDriverConfigPtr cfg;
+ virCapsPtr caps = NULL;
qemuDriverLock(driver);
cfg = virQEMUDriverGetConfig(driver);
- if (!(def = virDomainDefParseString(driver->caps, xml,
+
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (!(def = virDomainDefParseString(caps, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ caps,
def,
0,
&oldDef)))
qemuDomainEventQueue(driver, event);
virObjectUnref(qemuCaps);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return dom;
}
virQEMUCapsPtr qemuCaps = NULL;
qemuDomainObjPrivatePtr priv;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
affect = flags & (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG);
qemuDriverLock(driver);
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
goto endjob;
}
- dev = dev_copy = virDomainDeviceDefParse(driver->caps, vm->def, xml,
+ dev = dev_copy = virDomainDeviceDefParse(caps, vm->def, xml,
VIR_DOMAIN_XML_INACTIVE);
if (dev == NULL)
goto endjob;
* create a deep copy of device as adding
* to CONFIG takes one instance.
*/
- dev_copy = virDomainDeviceDefCopy(driver->caps, vm->def, dev);
+ dev_copy = virDomainDeviceDefCopy(caps, vm->def, dev);
if (!dev_copy)
goto endjob;
}
goto endjob;
/* Make a copy for updated domain. */
- vmdef = virDomainObjCopyPersistentDef(driver->caps, vm);
+ vmdef = virDomainObjCopyPersistentDef(caps, 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(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
ret = -1;
goto endjob;
}
if (vm)
virObjectUnlock(vm);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
virDomainDefPtr persistentDef = NULL;
int ret = -1;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
goto cleanup;
}
cfg = virQEMUDriverGetConfig(driver);
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (vm)
virObjectUnlock(vm);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
unsigned int val;
int ret = -1;
int rc;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
goto cleanup;
}
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
if ((*nparams) == 0) {
/* Current number of blkio parameters supported by cgroups */
*nparams = QEMU_NB_BLKIO_PARAM;
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
qemuDriverUnlock(driver);
return ret;
}
virQEMUDriverConfigPtr cfg = NULL;
int ret = -1;
int rc;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
cfg = virQEMUDriverGetConfig(driver);
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (vm)
virObjectUnlock(vm);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
virDomainDefPtr persistentDef = NULL;
int ret = -1;
int rc;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
qemuDriverUnlock(driver);
return ret;
}
virDomainObjPtr vm = NULL;
int ret = -1;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
}
cfg = virQEMUDriverGetConfig(driver);
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (vm)
virObjectUnlock(vm);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
char *nodeset = NULL;
int ret = -1;
int rc;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
qemuDriverUnlock(driver);
return ret;
}
int ret = -1;
int rc;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
cfg = virQEMUDriverGetConfig(driver);
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, 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(caps, vm);
if (!vmdef)
goto cleanup;
}
}
}
- if (virDomainSaveStatus(driver->caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
goto cleanup;
if (vm)
virObjectUnlock(vm);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
bool cpu_bw_status = false;
int saved_nparams = 0;
virDomainDefPtr persistentDef;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
qemuDriverUnlock(driver);
return ret;
}
virDomainNetDefPtr net = NULL, persistentNet = NULL;
virNetDevBandwidthPtr bandwidth = NULL, newBandwidth = NULL;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
cfg = virQEMUDriverGetConfig(driver);
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
if (vm)
virObjectUnlock(vm);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
virDomainDefPtr persistentDef = NULL;
virDomainNetDefPtr net = NULL;
int ret = -1;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
goto cleanup;
}
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
qemuDriverUnlock(driver);
return ret;
}
{
virQEMUDriverPtr driver = conn->privateData;
int ret = VIR_CPU_COMPARE_ERROR;
+ virCapsPtr caps = NULL;
virCheckFlags(0, VIR_CPU_COMPARE_ERROR);
qemuDriverLock(driver);
- if (!driver->caps) {
- virReportError(VIR_ERR_INTERNAL_ERROR,
- "%s", _("cannot get host capabilities"));
- } else if (!driver->caps->host.cpu ||
- !driver->caps->host.cpu->model) {
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (!caps->host.cpu ||
+ !caps->host.cpu->model) {
VIR_WARN("cannot get host CPU capabilities");
ret = VIR_CPU_COMPARE_INCOMPATIBLE;
} else {
- ret = cpuCompareXML(driver->caps->host.cpu, xmlDesc);
+ ret = cpuCompareXML(caps->host.cpu, xmlDesc);
}
+cleanup:
+ virObjectUnref(caps);
qemuDriverUnlock(driver);
-
return ret;
}
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(driver->caps, cfg->stateDir, vm) < 0 ||
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0 ||
(persist && virDomainSaveConfig(cfg->configDir, vm->newDef) < 0))
ret = -1;
}
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
int align_location = VIR_DOMAIN_SNAPSHOT_LOCATION_INTERNAL;
int align_match = true;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE |
VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT |
cfg = virQEMUDriverGetConfig(driver);
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
if (qemuProcessAutoDestroyActive(driver, vm)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("domain is marked for auto destroy"));
!virDomainObjIsActive(vm))
parse_flags |= VIR_DOMAIN_SNAPSHOT_PARSE_OFFLINE;
- if (!(def = virDomainSnapshotDefParseString(xmlDesc, driver->caps,
+ if (!(def = virDomainSnapshotDefParseString(xmlDesc, caps,
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(driver->caps, xml,
+ !(def->dom = virDomainDefParseString(caps, xml,
QEMU_EXPECTED_VIRT_TYPES,
VIR_DOMAIN_XML_INACTIVE)))
goto cleanup;
virDomainSnapshotDefFree(def);
VIR_FREE(xml);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return snapshot;
}
int rc;
virDomainDefPtr config = NULL;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING |
VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED |
cfg = virQEMUDriverGetConfig(driver);
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
if (virDomainHasDiskMirror(vm)) {
virReportError(VIR_ERR_BLOCK_COPY_ACTIVE, "%s",
_("domain has active block copy job"));
* than inactive xml? */
snap->def->current = true;
if (snap->def->dom) {
- config = virDomainDefCopy(driver->caps, snap->def->dom, true);
+ config = virDomainDefCopy(caps, snap->def->dom, true);
if (!config)
goto cleanup;
}
if (vm)
virObjectUnlock(vm);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
pid_t pid = pid_value;
char *pidfile = NULL;
virQEMUCapsPtr qemuCaps = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(0, NULL);
qemuDriverLock(driver);
- if (!(def = qemuParseCommandLinePid(driver->caps, pid,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (!(def = qemuParseCommandLinePid(caps, pid,
&pidfile, &monConfig, &monJSON)))
goto cleanup;
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
- driver->caps,
+ caps,
def,
VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE,
virObjectUnlock(vm);
qemuDriverUnlock(driver);
VIR_FREE(pidfile);
+ virObjectUnref(caps);
return dom;
}
bool set_bytes = false;
bool set_iops = false;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
priv = vm->privateData;
cfg = virQEMUDriverGetConfig(driver);
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block I/O throttling not supported with this "
if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto endjob;
if (vm)
virObjectUnlock(vm);
qemuDriverUnlock(driver);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
const char *device = NULL;
int ret = -1;
int i;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
goto cleanup;
}
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
if ((*nparams) == 0) {
/* Current number of parameters supported by QEMU Block I/O Throttling */
*nparams = QEMU_NB_BLOCK_IO_TUNE_PARAM;
if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto endjob;
VIR_FREE(device);
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
qemuDriverUnlock(driver);
return ret;
}
virDomainDefPtr persistentDef;
int ret = -1;
virQEMUDriverConfigPtr cfg = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, -1);
cfg = virQEMUDriverGetConfig(driver);
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags,
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
&persistentDef) < 0)
goto cleanup;
cleanup:
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
no_memory:
virDomainDefPtr def;
char *ret = NULL;
char *field = NULL;
+ virCapsPtr caps = NULL;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG, NULL);
if (!(vm = qemuDomObjFromDomain(dom)))
goto cleanup;
- if (virDomainLiveConfigHelperMethod(driver->caps, vm, &flags, &def) < 0)
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
+ if (virDomainLiveConfigHelperMethod(caps, vm, &flags, &def) < 0)
goto cleanup;
/* use correct domain definition according to flags */
cleanup:
if (vm)
virObjectUnlock(vm);
+ virObjectUnref(caps);
return ret;
}
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(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, 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) {
qemuDriverLock(driver);
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
}
+ 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(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, 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) {
qemuDriverLock(driver);
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
}
+ 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(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, 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) {
qemuDriverLock(driver);
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
}
+ virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
long long offset)
{
virQEMUDriverPtr driver = qemu_driver;
- virDomainEventPtr event;
+ 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(driver->caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
VIR_WARN("unable to save domain status with RTC change");
virObjectUnlock(vm);
+cleanup:
if (event) {
qemuDriverLock(driver);
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
}
-
+ 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(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, 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 || lifecycleEvent) {
qemuDriverLock(driver);
if (watchdogEvent)
qemuDriverUnlock(driver);
}
+ 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(driver->caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
VIR_WARN("Unable to save status on vm %s after IO error", vm->def->name);
}
virObjectUnlock(vm);
+cleanup:
if (ioErrorEvent || ioErrorEvent2 || lifecycleEvent) {
qemuDriverLock(driver);
if (ioErrorEvent)
qemuDomainEventQueue(driver, lifecycleEvent);
qemuDriverUnlock(driver);
}
-
+ 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(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, 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) {
qemuDriverLock(driver);
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
}
+ 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(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after wakeup event",
vm->def->name);
}
virObjectUnlock(vm);
+cleanup:
if (event || lifecycleEvent) {
qemuDriverLock(driver);
if (event)
qemuDomainEventQueue(driver, lifecycleEvent);
qemuDriverUnlock(driver);
}
-
+ 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(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after suspend event",
vm->def->name);
}
virObjectUnlock(vm);
+cleanup:
if (event || lifecycleEvent) {
qemuDriverLock(driver);
if (event)
qemuDomainEventQueue(driver, lifecycleEvent);
qemuDriverUnlock(driver);
}
+ virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
}
unsigned long long actual)
{
virQEMUDriverPtr driver = qemu_driver;
- virDomainEventPtr event;
+ 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(driver->caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
VIR_WARN("unable to save domain status with balloon change");
virObjectUnlock(vm);
+cleanup:
if (event) {
qemuDriverLock(driver);
qemuDomainEventQueue(driver, event);
qemuDriverUnlock(driver);
}
-
+ 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(driver->caps,cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
VIR_WARN("Unable to save status on vm %s after suspend event",
vm->def->name);
}
virObjectUnlock(vm);
+cleanup:
if (event || lifecycleEvent) {
qemuDriverLock(driver);
if (event)
qemuDomainEventQueue(driver, lifecycleEvent);
qemuDriverUnlock(driver);
}
-
+ virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
{
int i, hostcpus, maxcpu = QEMUD_CPUMASK_LEN;
virBitmapPtr cpumap = NULL;
+ virCapsPtr caps = NULL;
/* setaffinity fails if you set bits for CPUs which
* aren't present, so we have to limit ourselves */
}
if (nodemask) {
- for (i = 0; i < driver->caps->host.nnumaCell; i++) {
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false))) {
+ virBitmapFree(cpumap);
+ cpumap = NULL;
+ goto cleanup;
+ }
+
+ for (i = 0; i < caps->host.nnumaCell; i++) {
int j;
- int cur_ncpus = driver->caps->host.numaCell[i]->ncpus;
+ int cur_ncpus = caps->host.numaCell[i]->ncpus;
bool result;
if (virBitmapGetBit(nodemask, i, &result) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Failed to convert nodeset to cpuset"));
virBitmapFree(cpumap);
- return NULL;
+ cpumap = NULL;
+ goto cleanup;
}
if (result) {
for (j = 0; j < cur_ncpus; j++)
ignore_value(virBitmapSetBit(cpumap,
- driver->caps->host.numaCell[i]->cpus[j].id));
+ caps->host.numaCell[i]->cpus[j].id));
}
}
}
+cleanup:
+ virObjectUnref(caps);
return cpumap;
}
int state;
int reason;
virQEMUDriverConfigPtr cfg;
+ virCapsPtr caps = NULL;
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(driver->caps, cfg->stateDir, obj) < 0)
+ if (virDomainSaveStatus(caps, cfg->stateDir, obj) < 0)
goto error;
/* Run an hook to allow admins to do some magic */
virConnectClose(conn);
virObjectUnref(cfg);
+ virObjectUnref(caps);
return;
}
}
qemuDriverUnlock(driver);
-
virConnectClose(conn);
+ virObjectUnref(caps);
virObjectUnref(cfg);
}
virBitmapPtr nodemask = NULL;
unsigned int stop_flags;
virQEMUDriverConfigPtr cfg;
+ virCapsPtr caps = NULL;
/* Okay, these are just internal flags,
* but doesn't hurt to check */
return -1;
}
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
/* Do this upfront, so any part of the startup process can add
* runtime state to vm->def that won't be persisted. This let's us
* 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(caps, vm, true) < 0)
goto cleanup;
vm->def->id = qemuDriverAllocateID(driver);
}
VIR_DEBUG("Writing early domain status to disk");
- if (virDomainSaveStatus(driver->caps, cfg->stateDir, vm) < 0) {
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0) {
goto cleanup;
}
goto cleanup;
VIR_DEBUG("Writing domain status to disk");
- if (virDomainSaveStatus(driver->caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
goto cleanup;
/* finally we can call the 'started' hook script if any */
virCommandFree(cmd);
VIR_FORCE_CLOSE(logfile);
virObjectUnref(cfg);
+ virObjectUnref(caps);
return 0;
VIR_FORCE_CLOSE(logfile);
qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED, stop_flags);
virObjectUnref(cfg);
+ virObjectUnref(caps);
return -1;
}
virSecurityManagerPtr* sec_managers = NULL;
const char *model;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
+ virCapsPtr caps = NULL;
VIR_DEBUG("Beginning VM attach process");
return -1;
}
+ if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
+ goto cleanup;
+
/* Do this upfront, so any part of the startup process can add
* runtime state to vm->def that won't be persisted. This let's us
* 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(caps, 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(driver->caps, cfg->stateDir, vm) < 0)
+ if (virDomainSaveStatus(caps, cfg->stateDir, vm) < 0)
goto cleanup;
/* Run an hook to allow admins to do some magic */
VIR_FREE(seclabel);
VIR_FREE(sec_managers);
virObjectUnref(cfg);
+ virObjectUnref(caps);
return 0;
VIR_FREE(sec_managers);
virDomainChrSourceDefFree(monConfig);
virObjectUnref(cfg);
+ virObjectUnref(caps);
return -1;
}
projects / thirdparty / libvirt.git / commitdiff
