goto error;
}
...start qemu job...
- qemuDomainObjExitMonitor(driver, obj);
+ qemuDomainObjExitMonitor(obj);
while (!finished) {
if (qemuDomainObjEnterMonitorAsync(driver, obj,
goto error;
}
...monitor job progress...
- qemuDomainObjExitMonitor(driver, obj);
+ qemuDomainObjExitMonitor(obj);
virObjectUnlock(obj);
sleep(aWhile);
if (dd->added) {
qemuDomainObjEnterMonitor(priv->driver, vm);
qemuBlockStorageSourceAttachRollback(priv->mon, dd->crdata->srcdata[0]);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (dd->created) {
rc = qemuBlockStorageSourceAttachApply(priv->mon, dd->crdata->srcdata[0]);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
}
g_clear_pointer(&priv->backup, virDomainBackupDefFree);
if (priv->job.asyncJob == QEMU_ASYNC_JOB_BACKUP)
- qemuDomainObjEndAsyncJob(priv->driver, vm);
+ qemuDomainObjEndAsyncJob(vm);
}
rc = qemuMonitorBlockJobCancel(priv->mon, job->name, true);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc == 0) {
backupdisk->state = VIR_DOMAIN_BACKUP_DISK_STATE_CANCELLING;
if (rc == 0)
rc = qemuMonitorTransaction(priv->mon, &actions);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
/* note that if the export fails we've already created the checkpoint
* and we will not delete it */
rc = qemuBackupBeginPullExportDisks(vm, dd, ndd);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0) {
qemuBackupJobCancelBlockjobs(vm, priv->backup, false, QEMU_ASYNC_JOB_BACKUP);
ignore_value(qemuMonitorDelObject(priv->mon, tlsAlias, false));
if (tlsSecretAlias)
ignore_value(qemuMonitorDelObject(priv->mon, tlsSecretAlias, false));
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (ret < 0 && !job_started && priv->backup)
if (ret == 0)
qemuDomainObjReleaseAsyncJob(vm);
else
- qemuDomainObjEndAsyncJob(priv->driver, vm);
+ qemuDomainObjEndAsyncJob(vm);
return ret;
}
ignore_value(qemuMonitorDelObject(priv->mon, backup->tlsAlias, false));
if (backup->tlsSecretAlias)
ignore_value(qemuMonitorDelObject(priv->mon, backup->tlsSecretAlias, false));
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
/* update the final statistics with the current job's data */
backup->pull_tmp_used += cur;
rc = qemuMonitorGetJobInfo(priv->mon, &blockjobs, &nblockjobs);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
data = qemuMonitorQueryNamedBlockNodes(qemuDomainGetMonitor(vm));
blockstats = qemuMonitorQueryBlockstats(qemuDomainGetMonitor(vm));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (!data || !blockstats)
return -1;
if (ret == 0)
ret = qemuMonitorBlockdevDel(qemuDomainGetMonitor(vm), src->nodestorage);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
rc = qemuMonitorBlockdevCreate(priv->mon, job->name, &props);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
rc = qemuBlockStorageSourceAttachApplyStorageDeps(priv->mon, data);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
if (rc == 0)
rc = qemuBlockStorageSourceAttachApplyFormatDeps(priv->mon, data);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
rc = qemuBlockStorageSourceAttachApplyFormat(priv->mon, data);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) == 0) {
qemuBlockStorageSourceAttachRollback(priv->mon, data);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
return ret;
blockNamedNodeData = qemuMonitorBlockGetNamedNodeData(priv->mon, supports_flat);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (!blockNamedNodeData)
return NULL;
rc = qemuBlockReopenFormatMon(priv->mon, src);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
rc = qemuMonitorGetJobInfo(priv->mon, &jobinfo, &njobinfo);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
if (rc == -1 && jobinfo[i]->status == QEMU_MONITOR_JOB_STATUS_CONCLUDED)
VIR_WARN("can't cancel job '%s' with invalid data", job->name);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
qemuBlockJobUnregister(job, vm);
qemuBlockStorageSourceChainDetach(qemuDomainGetMonitor(vm), data);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
qemuDomainStorageSourceChainAccessRevoke(driver, vm, chain);
}
qemuMonitorTransaction(priv->mon, &actions);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
return 0;
}
qemuMonitorTransaction(priv->mon, &actions);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (!active) {
if (qemuBlockReopenReadOnly(vm, job->data.commit.base, asyncJob) < 0)
qemuMonitorTransaction(priv->mon, &actions);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
return 0;
}
disk->mirror->nodeformat,
"libvirt-tmp-activewrite");
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
/* Ideally, we would make the backing chain read only again (yes, SELinux
* can do that using different labels). But that is not implemented yet and
qemuBlockStorageSourceAttachRollback(qemuDomainGetMonitor(vm), backend);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
qemuDomainStorageSourceAccessRevoke(driver, vm, job->data.create.src);
}
job->disk->src->nodeformat,
job->data.backup.bitmap);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (job->data.backup.store)
qemuDomainStorageSourceAccessRevoke(driver, vm, job->data.backup.store);
/* dismiss job in qemu */
ignore_value(qemuMonitorJobDismiss(qemuDomainGetMonitor(vm), job->name));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if ((job->newstate == QEMU_BLOCKJOB_STATE_COMPLETED ||
job->newstate == QEMU_BLOCKJOB_STATE_FAILED) &&
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorTransaction(priv->mon, &actions);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
relabel:
for (next = relabelimages; next; next = next->next) {
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorTransaction(qemuDomainGetMonitor(vm), &actions);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0) {
qemuCheckpointRollbackMetadata(vm, chk);
return NULL;
checkpoint = virGetDomainCheckpoint(domain, chk->def->name);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return checkpoint;
}
if (rc == 0)
rc = qemuMonitorTransaction(priv->mon, &mergeactions);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
rc = qemuMonitorTransaction(priv->mon, &cleanupactions);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
}
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
void
-qemuDomainObjSaveStatus(virQEMUDriver *driver,
- virDomainObj *obj)
+qemuDomainSaveStatus(virDomainObj *obj)
{
+ qemuDomainObjPrivate *priv = obj->privateData;
+ virQEMUDriver *driver = priv->driver;
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
if (virDomainObjIsActive(obj)) {
}
-void
-qemuDomainSaveStatus(virDomainObj *obj)
-{
- qemuDomainObjSaveStatus(QEMU_DOMAIN_PRIVATE(obj)->driver, obj);
-}
-
-
void
qemuDomainSaveConfig(virDomainObj *obj)
{
if (!virDomainObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("domain is no longer running"));
- qemuDomainObjEndJob(driver, obj);
+ qemuDomainObjEndJob(obj);
return -1;
}
} else if (priv->job.asyncOwner == virThreadSelfID()) {
*
*/
void
-qemuDomainObjExitMonitor(virQEMUDriver *driver,
- virDomainObj *obj)
+qemuDomainObjExitMonitor(virDomainObj *obj)
{
qemuDomainObjPrivate *priv = obj->privateData;
bool hasRefs;
priv->mon = NULL;
if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
- qemuDomainObjEndJob(driver, obj);
+ qemuDomainObjEndJob(obj);
}
void qemuDomainObjEnterMonitor(virQEMUDriver *driver,
qemuDomainObjEnterMonitor(driver, vm);
/* we continue on even in the face of error */
qemuMonitorDeleteSnapshot(priv->mon, snap->def->name);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
}
qemuDomainRemoveInactive(driver, vm);
if (haveJob)
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
}
qemuDomainRemoveInactiveLocked(driver, vm);
if (haveJob)
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
}
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetDeviceAliases(priv->mon, &aliases);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
rc = qemuMonitorGetMemoryDeviceInfo(priv->mon, &meminfo);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
rc = qemuMonitorGetCPUInfo(qemuDomainGetMonitor(vm), &info, maxvcpus,
hotplug, fast);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
QEMU_CAPS_QUERY_CPUS_FAST);
haltedmap = qemuMonitorGetCpuHalted(qemuDomainGetMonitor(vm), maxvcpus,
fast);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (!haltedmap)
return -1;
ret = qemuMonitorCheck(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
#define QEMU_DOMAIN_MASTER_KEY_LEN 32 /* 32 bytes for 256 bit random key */
-void
-qemuDomainObjSaveStatus(virQEMUDriver *driver,
- virDomainObj *obj);
-
void qemuDomainSaveStatus(virDomainObj *obj);
void qemuDomainSaveConfig(virDomainObj *obj);
void qemuDomainObjEnterMonitor(virQEMUDriver *driver,
virDomainObj *obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjExitMonitor(virQEMUDriver *driver,
- virDomainObj *obj)
+void qemuDomainObjExitMonitor(virDomainObj *obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int qemuDomainObjEnterMonitorAsync(virQEMUDriver *driver,
virDomainObj *obj,
void
-qemuDomainObjSetJobPhase(virQEMUDriver *driver,
- virDomainObj *obj,
+qemuDomainObjSetJobPhase(virDomainObj *obj,
int phase)
{
qemuDomainObjPrivate *priv = obj->privateData;
priv->job.phase = phase;
priv->job.asyncOwner = me;
- qemuDomainObjSaveStatus(driver, obj);
+ qemuDomainSaveStatus(obj);
}
void
}
void
-qemuDomainObjDiscardAsyncJob(virQEMUDriver *driver, virDomainObj *obj)
+qemuDomainObjDiscardAsyncJob(virDomainObj *obj)
{
qemuDomainObjPrivate *priv = obj->privateData;
if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
qemuDomainObjResetJob(&priv->job);
qemuDomainObjResetAsyncJob(&priv->job);
- qemuDomainObjSaveStatus(driver, obj);
+ qemuDomainSaveStatus(obj);
}
void
}
if (qemuDomainTrackJob(job))
- qemuDomainObjSaveStatus(driver, obj);
+ qemuDomainSaveStatus(obj);
return 0;
* earlier qemuDomainBeginJob() call
*/
void
-qemuDomainObjEndJob(virQEMUDriver *driver, virDomainObj *obj)
+qemuDomainObjEndJob(virDomainObj *obj)
{
qemuDomainObjPrivate *priv = obj->privateData;
qemuDomainJob job = priv->job.active;
qemuDomainObjResetJob(&priv->job);
if (qemuDomainTrackJob(job))
- qemuDomainObjSaveStatus(driver, obj);
+ qemuDomainSaveStatus(obj);
/* We indeed need to wake up ALL threads waiting because
* grabbing a job requires checking more variables. */
virCondBroadcast(&priv->job.cond);
}
void
-qemuDomainObjEndAsyncJob(virQEMUDriver *driver, virDomainObj *obj)
+qemuDomainObjEndAsyncJob(virDomainObj *obj)
{
qemuDomainObjPrivate *priv = obj->privateData;
obj, obj->def->name);
qemuDomainObjResetAsyncJob(&priv->job);
- qemuDomainObjSaveStatus(driver, obj);
+ qemuDomainSaveStatus(obj);
virCondBroadcast(&priv->job.asyncCond);
}
qemuDomainJob job)
G_GNUC_WARN_UNUSED_RESULT;
-void qemuDomainObjEndJob(virQEMUDriver *driver,
- virDomainObj *obj);
+void qemuDomainObjEndJob(virDomainObj *obj);
void qemuDomainObjEndAgentJob(virDomainObj *obj);
-void qemuDomainObjEndAsyncJob(virQEMUDriver *driver,
- virDomainObj *obj);
+void qemuDomainObjEndAsyncJob(virDomainObj *obj);
void qemuDomainObjAbortAsyncJob(virDomainObj *obj);
-void qemuDomainObjSetJobPhase(virQEMUDriver *driver,
- virDomainObj *obj,
+void qemuDomainObjSetJobPhase(virDomainObj *obj,
int phase);
void qemuDomainObjSetAsyncJobMask(virDomainObj *obj,
unsigned long long allowedJobs);
int qemuDomainObjRestoreJob(virDomainObj *obj,
qemuDomainJobObj *job);
-void qemuDomainObjDiscardAsyncJob(virQEMUDriver *driver,
- virDomainObj *obj);
+void qemuDomainObjDiscardAsyncJob(virDomainObj *obj);
void qemuDomainObjReleaseAsyncJob(virDomainObj *obj);
int qemuDomainJobDataUpdateTime(virDomainJobData *jobData)
vm->def->name, virGetLastErrorMessage());
}
- qemuProcessEndJob(driver, vm);
+ qemuProcessEndJob(vm);
}
ret = 0;
start_flags) < 0) {
virDomainAuditStart(vm, "booted", false);
qemuDomainRemoveInactive(driver, vm);
- qemuProcessEndJob(driver, vm);
+ qemuProcessEndJob(vm);
goto cleanup;
}
dom = virGetDomain(conn, vm->def->name, vm->def->uuid, vm->def->id);
- qemuProcessEndJob(driver, vm);
+ qemuProcessEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainSetFakeReboot(vm, isReboot);
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSystemPowerdown(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
qemuDomainSetFakeReboot(vm, isReboot);
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSystemPowerdown(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
priv = vm->privateData;
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSystemReset(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
priv->fakeReboot = false;
virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_CRASHED);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
endjob:
if (ret == 0)
qemuDomainRemoveInactive(driver, vm);
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
priv = vm->privateData;
qemuDomainObjEnterMonitor(driver, vm);
r = qemuMonitorSetBalloon(priv->mon, newmem);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (r < 0)
goto endjob;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
r = qemuMonitorSetMemoryStatsPeriod(priv->mon, def->memballoon, period);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (r < 0) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("unable to set balloon driver collection period"));
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorInjectNMI(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSendKey(priv->mon, holdtime, keycodes, nkeycodes);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
virErrorRestore(&save_err);
}
}
- qemuDomainObjEndAsyncJob(driver, vm);
+ qemuDomainObjEndAsyncJob(vm);
if (ret == 0)
qemuDomainRemoveInactiveJob(driver, vm);
_("unsupported dumpformat '%s' "
"for this QEMU binary"),
dumpformat);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return -1;
}
}
ret = qemuMonitorDumpToFd(priv->mon, fd, dumpformat, detach);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
return -1;
if ((ret == 0) && (flags & VIR_DUMP_RESET)) {
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSystemReset(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (resume && virDomainObjIsActive(vm)) {
}
}
- qemuDomainObjEndAsyncJob(driver, vm);
+ qemuDomainObjEndAsyncJob(vm);
if (ret == 0 && flags & VIR_DUMP_CRASH)
qemuDomainRemoveInactiveJob(driver, vm);
qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorScreendump(priv->mon, videoAlias, screen, tmp) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto endjob;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (VIR_CLOSE(tmp_fd) < 0) {
virReportSystemError(errno, _("unable to close %s"), tmp);
if (unlink_tmp)
unlink(tmp);
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
}
endjob:
- qemuDomainObjEndAsyncJob(driver, vm);
+ qemuDomainObjEndAsyncJob(vm);
}
static int
}
endjob:
- qemuDomainObjEndAsyncJob(driver, vm);
+ qemuDomainObjEndAsyncJob(vm);
if (removeInactive)
qemuDomainRemoveInactiveJob(driver, vm);
}
qemuDomainSaveStatus(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
}
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorQueryRxFilter(priv->mon, devAlias, &guestFilter);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
goto endjob;
}
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virNetDevRxFilterFree(hostFilter);
}
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
}
qemuBlockJobUpdate(vm, job, QEMU_ASYNC_JOB_NONE);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
}
qemuBlockJobUpdate(vm, job, QEMU_ASYNC_JOB_NONE);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
}
endjob:
qemuDomainRemoveInactive(driver, vm);
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
}
mem->currentsize);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
virObjectEventStateQueue(driver->domainEventState, event);
}
if (useAgent)
qemuDomainObjEndAgentJob(vm);
else
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virObjectEventStateQueue(driver->domainEventState, event);
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorGetIOThreads(priv->mon, iothreads, niothreads);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
ret = niothreads;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
if (info_ret) {
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virObjectEventStateQueue(driver->domainEventState, event);
if (qemuMonitorGetIOThreads(priv->mon, &new_iothreads, &new_niothreads) < 0)
goto exit_monitor;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (new_niothreads != exp_niothreads) {
virReportError(VIR_ERR_INTERNAL_ERROR,
if (qemuMonitorDelObject(priv->mon, alias, true) < 0)
VIR_WARN("deletion of iothread object %d of domain %s failed when cleanup",
iothread_id, vm->def->name);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
}
return ret;
exit_monitor:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto cleanup;
}
rc = qemuMonitorSetIOThread(priv->mon, &iothread);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
if (qemuMonitorGetIOThreads(priv->mon, &new_iothreads, &new_niothreads) < 0)
goto exit_monitor;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (new_niothreads != exp_niothreads) {
virReportError(VIR_ERR_INTERNAL_ERROR,
return ret;
exit_monitor:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto cleanup;
}
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
ret = qemuSaveImageStartVM(conn, driver, vm, &fd, data, path,
false, reset_nvram, QEMU_ASYNC_JOB_START);
- qemuProcessEndJob(driver, vm);
+ qemuProcessEndJob(vm);
cleanup:
VIR_FORCE_CLOSE(fd);
ret = 0;
endjob:
- qemuProcessEndJob(driver, vm);
+ qemuProcessEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
}
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
if (dev != dev_copy)
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
vm->autostart = autostart;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
}
ret = 0;
}
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorBlockResize(priv->mon, device, nodename, size) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto endjob;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
rc = qemuMonitorBlockStatsUpdateCapacity(priv->mon, blockstats);
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (nstats < 0 || rc < 0)
return -1;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
*nparams = nstats;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
VIR_FREE(blockstats);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorGetMemoryStats(qemuDomainGetMonitor(vm),
vm->def->memballoon, stats, nr_stats);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0 || ret >= nr_stats)
return ret;
ret = qemuDomainMemoryStatsInternal(driver, vm, stats, nr_stats);
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
if (flags == VIR_MEMORY_VIRTUAL) {
if (qemuMonitorSaveVirtualMemory(priv->mon, offset, size, tmp) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto endjob;
}
} else {
if (qemuMonitorSavePhysicalMemory(priv->mon, offset, size, tmp) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto endjob;
}
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
/* Read the memory file into buffer. */
if (saferead(fd, buffer, size) == (ssize_t)-1) {
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
VIR_FORCE_CLOSE(fd);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
VIR_FREE(entry);
virDomainObjEndAPI(&vm);
rc = qemuMonitorQueryDump(priv->mon, &stats);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
ret = 0;
cleanup:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
qemuDomainObjAbortAsyncJob(vm);
qemuDomainObjEnterMonitor(priv->driver, vm);
ret = qemuMonitorMigrateCancel(priv->mon);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
}
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
} else {
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorSetMigrationDowntime(priv->mon, downtime);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
}
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
} else {
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorGetMigrationCacheSize(priv->mon, cacheSize);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
}
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
} else {
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorSetMigrationCacheSize(priv->mon, cacheSize);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
}
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorSetMigrationSpeed(priv->mon, bandwidth);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
}
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
cleanup:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
VIR_DEBUG("Starting post-copy");
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorMigrateStartPostCopy(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorArbitraryCommand(priv->mon, cmd, fd, result, hmp);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
} else {
ret = qemuMonitorDrivePivot(priv->mon, job->name);
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
/* The pivot failed. The block job in QEMU remains in the synchronised state */
if (ret < 0)
(!baseSource || basePath))
ret = qemuMonitorBlockStream(priv->mon, device, jobname, persistjob, basePath,
nodebase, backingPath, speed);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
goto endjob;
qemuBlockJobStarted(job, vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
qemuBlockJobStartupFinalize(vm, job);
} else {
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorBlockJobCancel(priv->mon, job->name, false);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
goto endjob;
endjob:
if (job && !async)
qemuBlockJobSyncEnd(vm, job, QEMU_ASYNC_JOB_NONE);
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
blockjobstats = qemuMonitorGetAllBlockJobInfo(qemuDomainGetMonitor(vm), true);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (!blockjobstats)
goto endjob;
ret = 1;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = qemuMonitorBlockJobSetSpeed(qemuDomainGetMonitor(vm),
job->name,
speed);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
if (data) {
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuBlockStorageSourceChainAttach(priv->mon, data);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
}
virDomainAuditDisk(vm, NULL, mirror, "mirror", ret >= 0);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0) {
qemuDomainStorageSourceChainAccessRevoke(driver, vm, mirror);
goto endjob;
qemuBlockStorageSourceChainDetach(priv->mon, data);
if (crdata)
qemuBlockStorageSourceAttachRollback(priv->mon, crdata->srcdata[0]);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (need_revoke)
qemuDomainStorageSourceChainAccessRevoke(driver, vm, mirror);
if (need_unlink && virStorageSourceUnlink(mirror) < 0)
VIR_WARN("%s", _("unable to remove just-created copy target"));
virStorageSourceDeinit(mirror);
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
qemuBlockJobStartupFinalize(vm, job);
return ret;
topPath, nodetop, basePath, nodebase,
backingPath, speed);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
goto endjob;
virErrorRestore(&orig_err);
}
qemuBlockJobStartupFinalize(vm, job);
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorOpenGraphics(priv->mon, protocol, fd, "graphicsfd",
(flags & VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH) != 0);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorOpenGraphics(priv->mon, protocol, pair[1], "graphicsfd",
(flags & VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH));
- qemuDomainObjExitMonitor(driver, vm);
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjExitMonitor(vm);
+ qemuDomainObjEndJob(vm);
if (ret < 0)
goto cleanup;
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorSetBlockIoThrottle(priv->mon, drivealias, qdevid, &info);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
VIR_FREE(info.group_name);
}
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorGetBlockIoThrottle(priv->mon, drivealias, qdevid, &reply);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
VIR_FREE(reply.group_name);
qemuDomainObjEnterMonitor(driver, vm);
table = qemuMonitorGetBlockInfo(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (!table)
goto endjob;
ret = n;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
virObjectEventStateQueue(driver->domainEventState, ev);
}
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
rv = qemuMonitorGetCurrentMachineInfo(priv->mon, &info);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rv < 0)
return -1;
ret = qemuDomainProbeQMPCurrentMachine(driver, vm, wakeupSupported);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSystemWakeup(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_RTC_RESET_REINJECTION)) {
qemuDomainObjEnterMonitor(driver, vm);
rv = qemuMonitorRTCResetReinjection(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rv < 0)
goto endjob;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
if (fetchnodedata)
nodedata = qemuMonitorQueryNamedBlockNodes(priv->mon);
- qemuDomainObjExitMonitor(driver, dom);
+ qemuDomainObjExitMonitor(dom);
/* failure to retrieve stats is fine at this point */
if (rc < 0 || (fetchnodedata && !nodedata))
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorQueryDirtyRate(priv->mon, info);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
rc = qemuDomainGetStats(conn, vm, requestedStats, &tmp, domflags);
if (HAVE_JOB(domflags))
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
virObjectUnlock(vm);
ret = virDomainFSInfoFormat(agentinfo, nfs, vm->def, info);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
if (agentinfo) {
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
ret = qemuDomainSetVcpuInternal(driver, vm, def, persistentDef, map, !!state);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorSetBlockThreshold(priv->mon, nodename, threshold);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
QEMU_MONITOR_ACTION_WATCHDOG_KEEP,
QEMU_MONITOR_ACTION_PANIC_KEEP);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
if (!tmp) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto endjob;
}
rv = qemuMonitorGetSEVInfo(QEMU_DOMAIN_PRIVATE(vm)->mon,
&apiMajor, &apiMinor, &buildID, &policy);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rv < 0)
goto endjob;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorSetLaunchSecurityState(QEMU_DOMAIN_PRIVATE(vm)->mon,
secrethdr, secret, setaddr, hasSetaddr);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
qemuAgentDiskInfoFormatParams(agentdiskinfo, ndisks, vm->def, params, nparams, &maxparams);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
}
if (nifaces > 0) {
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorStartDirtyRateCalc(priv->mon, seconds, mode);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virDomainObjEndAPI(&vm);
rc = qemuMonitorDelDevice(priv->mon, alias);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0) {
/* Deleting device failed. Let's check if DEVICE_DELETED
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorEjectMedia(priv->mon, driveAlias, force);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
/* If the tray is present wait for it to open. */
if (!force && diskPriv->tray) {
/* re-issue ejection command to pop out the media */
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorEjectMedia(priv->mon, driveAlias, false);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
driveAlias,
sourcestr,
format);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (rc < 0)
if (ret == 0)
priv->dbusVMState = true;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
if (ret == 0)
priv->dbusVMState = false;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
rc = qemuMonitorAddObject(priv->mon, &props, NULL);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
goto cleanup;
ignore_value(qemuMonitorDelObject(priv->mon, qemuDomainGetManagedPRAlias(),
false));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
qemuProcessKillManagedPRDaemon(vm);
if (diskPriv->tray && disk->tray_status != VIR_DOMAIN_DISK_TRAY_OPEN) {
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorBlockdevTrayOpen(priv->mon, diskPriv->qomName, force);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
if (rc < 0 && newbackend)
qemuBlockStorageSourceChainDetach(priv->mon, newbackend);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
rc = qemuBlockStorageSourceChainAttach(priv->mon, data);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto rollback;
VIR_WARN("failed to set blkdeviotune for '%s' of '%s'", disk->dst, vm->def->name);
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto rollback;
qemuBlockStorageSourceChainDetach(priv->mon, data);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return -1;
}
ignore_value(qemuDomainDetachExtensionDevice(priv->mon, &controller->info));
exit_monitor:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret == 0)
virDomainControllerInsertPreAlloced(vm->def, controller);
if (qemuMonitorAddFileHandleToSet(priv->mon, vdpafd, -1,
net->data.vdpa.devicepath,
&fdinfo) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto cleanup;
}
vdpafdName = g_strdup_printf("/dev/fdset/%d", fdinfo.fdset);
tapfdName, tapfdSize,
vhostfdName, vhostfdSize,
slirpfdName, vdpafdName))) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto cleanup;
}
if (actualType == VIR_DOMAIN_NET_TYPE_VHOSTUSER) {
if (qemuHotplugChardevAttach(priv->mon, charDevAlias, net->data.vhostuser) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto cleanup;
}
tapfd, tapfdName, tapfdSize,
vhostfd, vhostfdName, vhostfdSize,
slirpfd, slirpfdName) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto try_remove;
}
netdevPlugged = true;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
for (i = 0; i < tapfdSize; i++)
VIR_FORCE_CLOSE(tapfd[i]);
qemuDomainObjEnterMonitor(driver, vm);
if (qemuDomainAttachExtensionDevice(priv->mon, &net->info) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto try_remove;
}
if (qemuMonitorAddDeviceProps(priv->mon, &nicprops) < 0) {
ignore_value(qemuDomainDetachExtensionDevice(priv->mon, &net->info));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto try_remove;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
/* set link state */
if (net->linkstate == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) {
qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorSetLink(priv->mon, net->info.alias, VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto try_remove;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
/* link set to down */
}
qemuMonitorRemoveNetdev(priv->mon, netdev_name) < 0)
VIR_WARN("Failed to remove network backend for netdev %s",
netdev_name);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virErrorRestore(&originalError);
goto cleanup;
}
ignore_value(qemuDomainDetachExtensionDevice(priv->mon, hostdev->info));
exit_monitor:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
done:
virDomainAuditHostdev(vm, hostdev, "attach", ret == 0);
if (secAlias)
ignore_value(qemuMonitorDelObject(priv->mon, secAlias, false));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
cleanup:
virErrorRestore(&orig_err);
qemuMonitorAddObject(priv->mon, tlsProps, NULL) < 0)
goto error;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return 0;
error:
virErrorPreserveLast(&orig_err);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
qemuDomainDelTLSObjects(driver, vm, asyncJob, secAlias, NULL);
if (secAlias)
ignore_value(qemuMonitorDelObject(priv->mon, secAlias, false));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return 0;
}
if (qemuMonitorAddDeviceProps(priv->mon, &devprops) < 0)
goto exit_monitor;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
def->redirdevs[def->nredirdevs++] = redirdev;
ret = 0;
/* detach associated chardev on error */
if (chardevAdded)
ignore_value(qemuMonitorDetachCharDev(priv->mon, charAlias));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
qemuDomainDelTLSObjects(driver, vm, QEMU_ASYNC_JOB_NONE,
secAlias, tlsAlias);
qemuFDPassTransferMonitor(charpriv->logfd, priv->mon) < 0)
goto exit_monitor;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (guestfwd) {
goto exit_monitor;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
qemuDomainChrInsertPreAlloced(vmdef, chr);
ret = 0;
qemuMonitorDetachCharDev(priv->mon, charAlias);
qemuFDPassTransferMonitorRollback(charpriv->sourcefd, priv->mon);
qemuFDPassTransferMonitorRollback(charpriv->logfd, priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
qemuDomainDelTLSObjects(driver, vm, QEMU_ASYNC_JOB_NONE,
goto exit_monitor;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
VIR_APPEND_ELEMENT_INPLACE(vm->def->rngs, vm->def->nrngs, rng);
ignore_value(qemuMonitorDelObject(priv->mon, objAlias, false));
if (rng->backend == VIR_DOMAIN_RNG_BACKEND_EGD && chardevAdded)
ignore_value(qemuMonitorDetachCharDev(priv->mon, charAlias));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
qemuDomainDelTLSObjects(driver, vm, QEMU_ASYNC_JOB_NONE,
if (qemuMonitorAddDeviceProps(priv->mon, &devprops) < 0)
goto exit_monitor;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
event = virDomainEventDeviceAddedNewFromObj(vm, objalias);
virObjectEventStateQueue(driver->domainEventState, event);
virErrorPreserveLast(&orig_err);
if (objAdded)
ignore_value(qemuMonitorDelObject(priv->mon, objalias, false));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (objAdded && mem)
ignore_value(qemuProcessDestroyMemoryBackingPath(driver, vm, mem));
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorAddDeviceProps(priv->mon, &devprops);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditHostdev(vm, hostdev, "attach", ret == 0);
if (ret < 0)
goto cleanup;
if (qemuMonitorAddDeviceProps(priv->mon, &devprops) < 0)
goto exit_monitor;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditHostdev(vm, hostdev, "attach", true);
exit_monitor:
virErrorPreserveLast(&orig_err);
qemuBlockStorageSourceAttachRollback(priv->mon, data);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
virDomainAuditHostdev(vm, hostdev, "attach", false);
ignore_value(qemuMonitorCloseFileHandle(priv->mon, vhostfdName));
if (removeextension)
ignore_value(qemuDomainDetachExtensionDevice(priv->mon, hostdev->info));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
goto audit;
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorAddDeviceProps(priv->mon, &devprops);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditHostdev(vm, hostdev, "attach", ret == 0);
if (ret < 0)
goto exit_monitor;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
/* Doing a copy here just so the pointer doesn't get nullified
* because we need it in the audit function */
ignore_value(qemuMonitorDelObject(priv->mon, memAlias, false));
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
if (rv >= 0)
rv = qemuMonitorAddDeviceProps(priv->mon, &props);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rv < 0)
goto cleanup;
goto exit_monitor;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
VIR_APPEND_ELEMENT_COPY_INPLACE(vm->def->inputs, vm->def->ninputs, input);
return ret;
exit_monitor:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto audit;
}
if ((ret = qemuMonitorAddDeviceProps(priv->mon, &devprops)) < 0)
goto exit_monitor;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
vm->def->vsock = g_steal_pointer(&vsock);
ignore_value(qemuMonitorCloseFileHandle(priv->mon, fdname));
if (removeextension)
ignore_value(qemuDomainDetachExtensionDevice(priv->mon, &vsock->info));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto cleanup;
}
goto exit_monitor;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
VIR_APPEND_ELEMENT_COPY(vm->def->fss, vm->def->nfss, fs);
virErrorPreserveLast(&origErr);
if (chardevAdded)
ignore_value(qemuMonitorDetachCharDev(priv->mon, charAlias));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virErrorRestore(&origErr);
goto audit;
}
dev->linkstate = linkstate;
cleanup:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
ret = qemuMonitorExpirePassword(priv->mon, type, expire);
end_job:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
if (diskBackend)
qemuBlockStorageSourceChainDetach(priv->mon, diskBackend);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditDisk(vm, disk->src, NULL, "detach", true);
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorDelObject(priv->mon, backendAlias, true);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditMemory(vm, oldmem, newmem, "update", rc == 0);
if (rc < 0)
qemuDomainObjEnterMonitor(driver, vm);
qemuBlockStorageSourceAttachRollback(priv->mon, detachscsi);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (hostdev->parentnet) {
qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditNet(vm, net, NULL, "detach", false);
return -1;
}
qemuHotplugRemoveFDSet(priv->mon, net->info.alias, net->data.vdpa.devicepath);
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp)
qemuSlirpStop(QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp, vm, driver, net);
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorDetachCharDev(priv->mon, charAlias);
qemuHotplugRemoveFDSet(priv->mon, chr->info.alias, NULL);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (rc == 0 &&
qemuMonitorDetachCharDev(priv->mon, charAlias) < 0)
rc = -1;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rng->backend == VIR_DOMAIN_RNG_BACKEND_EGD &&
rc == 0 &&
else
rc = qemuMonitorDelObject(priv->mon, memAlias, true);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditShmem(vm, shmem, "detach", rc == 0);
*/
ignore_value(qemuMonitorDetachCharDev(priv->mon, charAlias));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (qemuDomainDelChardevTLSObjects(driver, vm, dev->source, charAlias) < 0)
return -1;
if (qemuMonitorDetachCharDev(priv->mon, charAlias) < 0)
rc = -1;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
virDomainAuditFS(vm, fs, NULL, "detach", rc == 0);
int rc;
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorRemoveNetdev(priv->mon, tmpChr->info.alias);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
rc = qemuMonitorAddDeviceProps(qemuDomainGetMonitor(vm), &vcpuprops);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virDomainAuditVcpu(vm, oldvcpus, oldvcpus + nvcpus, "update", rc == 0);
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorChangeMemoryRequestedSize(priv->mon, alias, requestedsize);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return rc;
}
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
static void
-qemuMigrationJobSetPhase(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationJobSetPhase(virDomainObj *vm,
qemuMigrationJobPhase phase)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
+ ATTRIBUTE_NONNULL(1);
static void
-qemuMigrationJobStartPhase(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationJobStartPhase(virDomainObj *vm,
qemuMigrationJobPhase phase)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
+ ATTRIBUTE_NONNULL(1);
static void
qemuMigrationJobContinue(virDomainObj *obj)
ATTRIBUTE_NONNULL(1);
static void
-qemuMigrationJobFinish(virQEMUDriver *driver,
- virDomainObj *obj)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
+qemuMigrationJobFinish(virDomainObj *obj)
+ ATTRIBUTE_NONNULL(1);
static void
qemuMigrationSrcStoreDomainState(virDomainObj *vm)
if (qemuBlockExportAddNBD(vm, diskAlias, disk->src, diskAlias, true, NULL) < 0)
goto exit_monitor;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (server.transport == VIR_STORAGE_NET_HOST_TRANS_TCP)
return ret;
exit_monitor:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto cleanup;
}
if (qemuMonitorNBDServerStop(priv->mon) < 0)
VIR_WARN("Unable to stop NBD server");
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
virPortAllocatorRelease(priv->nbdPort);
priv->nbdPort = 0;
* consistency on the destination so that we can force cancel the mirror */
rv = qemuMonitorBlockJobCancel(priv->mon, job->name, abortMigration);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rv < 0)
return -1;
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
return -1;
qemuMonitorBitmapRemove(priv->mon, t->nodename, t->bitmapname);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
return 0;
if (mon_ret != 0)
qemuBlockStorageSourceAttachRollback(qemuDomainGetMonitor(vm), data);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (mon_ret < 0)
return -1;
diskAlias, nbd_dest, "raw",
mirror_speed, 0, 0, mirror_shallow, true);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (mon_ret < 0)
return -1;
rv = qemuMonitorGetMigrationStats(priv->mon, &stats, error);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rv < 0)
return -1;
ret = qemuMonitorGraphicsRelocate(priv->mon, type, listenAddress,
port, tlsPort, tlsSubject);
jobPriv->spiceMigration = !ret;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
cleanup:
rv = qemuMonitorMigrateIncoming(priv->mon, uri);
exit_monitor:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rv < 0)
return -1;
switch ((qemuMigrationJobPhase) priv->job.phase) {
case QEMU_MIGRATION_PHASE_BEGIN3:
/* just forget we were about to migrate */
- qemuMigrationJobFinish(driver, vm);
+ qemuMigrationJobFinish(vm);
break;
case QEMU_MIGRATION_PHASE_PERFORM3_DONE:
qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT,
jobPriv->migParams, priv->job.apiFlags);
/* clear the job and let higher levels decide what to do */
- qemuMigrationJobFinish(driver, vm);
+ qemuMigrationJobFinish(vm);
break;
case QEMU_MIGRATION_PHASE_PERFORM3:
* change protection.
*/
if (priv->job.asyncJob == QEMU_ASYNC_JOB_MIGRATION_OUT)
- qemuMigrationJobSetPhase(driver, vm, QEMU_MIGRATION_PHASE_BEGIN3);
+ qemuMigrationJobSetPhase(vm, QEMU_MIGRATION_PHASE_BEGIN3);
if (!qemuMigrationSrcIsAllowed(driver, vm, true, flags))
return NULL;
endjob:
if (flags & VIR_MIGRATE_CHANGE_PROTECTION)
- qemuMigrationJobFinish(driver, vm);
+ qemuMigrationJobFinish(vm);
else
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
goto cleanup;
}
if (!qemuMigrationJobIsActive(vm, QEMU_ASYNC_JOB_MIGRATION_IN))
return;
- qemuDomainObjDiscardAsyncJob(driver, vm);
+ qemuDomainObjDiscardAsyncJob(vm);
}
static qemuProcessIncomingDef *
if (qemuMigrationJobStart(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN,
flags) < 0)
goto cleanup;
- qemuMigrationJobSetPhase(driver, vm, QEMU_MIGRATION_PHASE_PREPARE);
+ qemuMigrationJobSetPhase(vm, QEMU_MIGRATION_PHASE_PREPARE);
/* Domain starts inactive, even if the domain XML had an id field. */
vm->def->id = -1;
QEMU_ASYNC_JOB_MIGRATION_IN, stopFlags);
}
- qemuMigrationJobFinish(driver, vm);
+ qemuMigrationJobFinish(vm);
goto cleanup;
}
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
- qemuMigrationJobSetPhase(driver, vm,
+ qemuMigrationJobSetPhase(vm,
retcode == 0
? QEMU_MIGRATION_PHASE_CONFIRM3
: QEMU_MIGRATION_PHASE_CONFIRM3_CANCELLED);
else
phase = QEMU_MIGRATION_PHASE_CONFIRM3;
- qemuMigrationJobStartPhase(driver, vm, phase);
+ qemuMigrationJobStartPhase(vm, phase);
virCloseCallbacksUnset(driver->closeCallbacks, vm,
qemuMigrationSrcCleanup);
cookiein, cookieinlen,
flags, cancelled);
- qemuMigrationJobFinish(driver, vm);
+ qemuMigrationJobFinish(vm);
if (!virDomainObjIsActive(vm)) {
if (!cancelled && ret == 0 && flags & VIR_MIGRATE_UNDEFINE_SOURCE) {
virDomainDeleteConfig(cfg->configDir, cfg->autostartDir, vm);
ret = qemuMonitorMigrateContinue(priv->mon, status);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
rv = qemuMonitorSetDBusVMStateIdList(priv->mon, priv->dbusVMStateIds);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return rv;
} else {
rc = qemuMonitorTransaction(priv->mon, &actions);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
break;
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto error;
qemuDomainObjEnterMonitorAsync(driver, vm,
QEMU_ASYNC_JOB_MIGRATION_OUT) == 0) {
qemuMonitorMigrateCancel(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
/* cancel any outstanding NBD jobs */
goto cleanup;
exit_monitor:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto error;
}
* until the migration is complete.
*/
VIR_DEBUG("Perform %p", sconn);
- qemuMigrationJobSetPhase(driver, vm, QEMU_MIGRATION_PHASE_PERFORM2);
+ qemuMigrationJobSetPhase(vm, QEMU_MIGRATION_PHASE_PERFORM2);
if (flags & VIR_MIGRATE_TUNNELLED)
ret = qemuMigrationSrcPerformTunnel(driver, vm, st, NULL,
NULL, 0, NULL, NULL,
* confirm migration completion.
*/
VIR_DEBUG("Perform3 %p uri=%s", sconn, NULLSTR(uri));
- qemuMigrationJobSetPhase(driver, vm, QEMU_MIGRATION_PHASE_PERFORM3);
+ qemuMigrationJobSetPhase(vm, QEMU_MIGRATION_PHASE_PERFORM3);
VIR_FREE(cookiein);
cookiein = g_steal_pointer(&cookieout);
cookieinlen = cookieoutlen;
if (ret < 0) {
virErrorPreserveLast(&orig_err);
} else {
- qemuMigrationJobSetPhase(driver, vm,
- QEMU_MIGRATION_PHASE_PERFORM3_DONE);
+ qemuMigrationJobSetPhase(vm, QEMU_MIGRATION_PHASE_PERFORM3_DONE);
}
/* If Perform returns < 0, then we need to cancel the VM
migParams, flags, dname, resource,
&v3proto);
} else {
- qemuMigrationJobSetPhase(driver, vm, QEMU_MIGRATION_PHASE_PERFORM2);
+ qemuMigrationJobSetPhase(vm, QEMU_MIGRATION_PHASE_PERFORM2);
ret = qemuMigrationSrcPerformNative(driver, vm, persist_xml, uri, cookiein, cookieinlen,
cookieout, cookieoutlen,
flags, resource, NULL, NULL, 0, NULL,
qemuMigrationSrcRestoreDomainState(driver, vm);
- qemuMigrationJobFinish(driver, vm);
+ qemuMigrationJobFinish(vm);
if (!virDomainObjIsActive(vm) && ret == 0) {
if (flags & VIR_MIGRATE_UNDEFINE_SOURCE) {
virDomainDeleteConfig(cfg->configDir, cfg->autostartDir, vm);
return ret;
}
- qemuMigrationJobStartPhase(driver, vm, QEMU_MIGRATION_PHASE_PERFORM3);
+ qemuMigrationJobStartPhase(vm, QEMU_MIGRATION_PHASE_PERFORM3);
virCloseCallbacksUnset(driver->closeCallbacks, vm,
qemuMigrationSrcCleanup);
goto endjob;
}
- qemuMigrationJobSetPhase(driver, vm, QEMU_MIGRATION_PHASE_PERFORM3_DONE);
+ qemuMigrationJobSetPhase(vm, QEMU_MIGRATION_PHASE_PERFORM3_DONE);
if (virCloseCallbacksSet(driver->closeCallbacks, vm, conn,
qemuMigrationSrcCleanup) < 0)
if (ret < 0) {
qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT,
jobPriv->migParams, priv->job.apiFlags);
- qemuMigrationJobFinish(driver, vm);
+ qemuMigrationJobFinish(vm);
} else {
qemuMigrationJobContinue(vm);
}
ignore_value(virTimeMillisNow(&timeReceived));
- qemuMigrationJobStartPhase(driver, vm,
+ qemuMigrationJobStartPhase(vm,
v3proto ? QEMU_MIGRATION_PHASE_FINISH3
: QEMU_MIGRATION_PHASE_FINISH2);
qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN,
jobPriv->migParams, priv->job.apiFlags);
- qemuMigrationJobFinish(driver, vm);
+ qemuMigrationJobFinish(vm);
if (!virDomainObjIsActive(vm))
qemuDomainRemoveInactiveJob(driver, vm);
qemuMonitorSetMigrationSpeed(priv->mon,
QEMU_DOMAIN_MIG_BANDWIDTH_MAX);
priv->migMaxBandwidth = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
}
if (virSetCloseExec(pipeFD[1]) < 0) {
virReportSystemError(errno, "%s",
_("Unable to set cloexec flag"));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto cleanup;
}
if (virCommandRunAsync(compressor, NULL) < 0) {
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
goto cleanup;
}
rc = qemuMonitorMigrateToFd(priv->mon,
VIR_CLOSE(pipeFD[1]) < 0)
VIR_WARN("failed to close intermediate pipe");
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
if (virDomainObjIsActive(vm) &&
qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
qemuMonitorMigrateCancel(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
}
goto cleanup;
} else {
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
qemuMonitorSetMigrationSpeed(priv->mon, saveMigBandwidth);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
}
priv->migMaxBandwidth = saveMigBandwidth;
qemuDomainObjEnterMonitor(driver, vm);
ignore_value(qemuMonitorMigrateCancel(priv->mon));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
for (i = 0; i < vm->def->ndisks; i++) {
virDomainDiskDef *disk = vm->def->disks[i];
}
static void
-qemuMigrationJobSetPhase(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationJobSetPhase(virDomainObj *vm,
qemuMigrationJobPhase phase)
{
qemuDomainObjPrivate *priv = vm->privateData;
return;
}
- qemuDomainObjSetJobPhase(driver, vm, phase);
+ qemuDomainObjSetJobPhase(vm, phase);
}
static void
-qemuMigrationJobStartPhase(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationJobStartPhase(virDomainObj *vm,
qemuMigrationJobPhase phase)
{
- qemuMigrationJobSetPhase(driver, vm, phase);
+ qemuMigrationJobSetPhase(vm, phase);
}
static void
}
static void
-qemuMigrationJobFinish(virQEMUDriver *driver, virDomainObj *vm)
+qemuMigrationJobFinish(virDomainObj *vm)
{
- qemuDomainObjEndAsyncJob(driver, vm);
+ qemuDomainObjEndAsyncJob(vm);
}
blockinfo = qemuMonitorGetAllBlockJobInfo(priv->mon, false);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (!blockinfo)
return -1;
rc = qemuMonitorBlockStatsUpdateCapacityBlockdev(priv->mon, stats);
else
rc = qemuMonitorBlockStatsUpdateCapacity(priv->mon, stats);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
ret = 0;
cleanup:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (xbzrleCacheSize_old)
migParams->params[xbzrle].set = true;
rc = qemuMonitorGetMigrationParams(priv->mon, &jsonParams);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
rc = qemuMonitorGetMigrationCapabilities(priv->mon, &caps);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
rc = qemuMonitorSetMigrationCapabilities(priv->mon, &json);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0) {
virResetLastError();
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorSystemReset(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto endjob;
ret = 0;
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
priv->pausedShutdown = false;
ret = qemuMonitorSetCapabilities(QEMU_DOMAIN_PRIVATE(vm)->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
return -1;
rc = qemuMonitorGetChardevInfo(priv->mon, &info);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorGetPRManagerInfo(priv->mon, &info);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
qemuDomainObjEnterMonitor(driver, vm);
now = time(NULL);
rv = qemuMonitorGetRTCTime(priv->mon, &thenbits);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rv < 0)
return;
return -1;
rc = qemuMonitorGetBalloonInfo(qemuDomainGetMonitor(vm), &balloon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
goto cleanup;
ret = qemuMonitorGetChardevInfo(priv->mon, &info);
VIR_DEBUG("qemuMonitorGetChardevInfo returned %i", ret);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret == 0) {
if ((ret = qemuProcessFindCharDevicePTYsMonitor(vm, info)) < 0)
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
goto cleanup;
ret = qemuMonitorGetIOThreads(priv->mon, &iothreads, &niothreads);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
goto cleanup;
ret = 0;
cleanup:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
cfg = virQEMUDriverGetConfig(driver);
ret = virDomainObjSave(vm, driver->xmlopt, cfg->stateDir);
return ret;
error:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return -1;
}
goto release;
ret = qemuMonitorStartCPUs(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
goto release;
goto cleanup;
ret = qemuMonitorStopCPUs(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
goto cleanup;
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorGetStatus(priv->mon, &running, &reason);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
return -1;
case QEMU_ASYNC_JOB_SNAPSHOT:
qemuDomainObjEnterMonitor(driver, vm);
ignore_value(qemuMonitorMigrateCancel(priv->mon));
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
/* resume the domain but only if it was paused as a result of
* running a migration-to-file operation. Although we are
* recovering an async job, this function is run at startup
rc = qemuMonitorGetGuestCPUx86(priv->mon, cpuQOMPath, &dataEnabled, &dataDisabled);
}
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc == -1)
return -1;
rc = virQEMUCapsFetchCPUModels(priv->mon, vm->def->os.arch, &models);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
void
-qemuProcessEndJob(virQEMUDriver *driver,
- virDomainObj *vm)
+qemuProcessEndJob(virDomainObj *vm)
{
- qemuDomainObjEndAsyncJob(driver, vm);
+ qemuDomainObjEndAsyncJob(vm);
}
ret = 0;
cleanup:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
rc = qemuMonitorAddDeviceProps(qemuDomainGetMonitor(vm), &vcpuprops);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
goto cleanup;
ret = 0;
cleanup:
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
return ret;
}
rc = qemuMonitorSystemReset(priv->mon);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
}
QEMU_MONITOR_ACTION_WATCHDOG_KEEP,
QEMU_MONITOR_ACTION_PANIC_KEEP);
- qemuDomainObjExitMonitor(priv->driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
endjob:
if (asyncJob != QEMU_ASYNC_JOB_NONE)
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
cleanup:
virErrorRestore(&orig_err);
if (priv->job.asyncJob) {
VIR_DEBUG("vm=%s has long-term job active, cancelling",
dom->def->name);
- qemuDomainObjDiscardAsyncJob(driver, dom);
+ qemuDomainObjDiscardAsyncJob(dom);
}
VIR_DEBUG("Killing domain");
qemuDomainRemoveInactive(driver, dom);
- qemuDomainObjEndJob(driver, dom);
+ qemuDomainObjEndJob(dom);
virObjectEventStateQueue(driver->domainEventState, event);
}
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
table = qemuMonitorGetBlockInfo(priv->mon);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
if (!table)
rc = qemuMonitorGetCPUMigratable(priv->mon, cpuQOMPath, &migratable);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
qemuDomainObjEnterMonitor(driver, vm);
blockJobs = qemuMonitorGetAllBlockJobInfo(qemuDomainGetMonitor(vm), true);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (!blockJobs)
return -1;
if (jobStarted) {
if (!virDomainObjIsActive(obj))
qemuDomainRemoveInactive(driver, obj);
- qemuDomainObjEndJob(driver, obj);
+ qemuDomainObjEndJob(obj);
} else {
if (!virDomainObjIsActive(obj))
qemuDomainRemoveInactiveJob(driver, obj);
virDomainObj *vm,
virDomainJobOperation operation,
unsigned long apiFlags);
-void qemuProcessEndJob(virQEMUDriver *driver,
- virDomainObj *vm);
+void qemuProcessEndJob(virDomainObj *vm);
typedef enum {
VIR_QEMU_PROCESS_START_COLD = 1 << 0,
}
ret = qemuMonitorCreateSnapshot(priv->mon, snap->def->name);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (ret < 0)
goto cleanup;
qemuBlockStorageSourceAttachRollback(qemuDomainGetMonitor(vm),
data[i].crdata->srcdata[0]);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
}
}
rc = qemuBlockStorageSourceAttachApply(qemuDomainGetMonitor(vm),
dd->crdata->srcdata[0]);
- qemuDomainObjExitMonitor(driver, vm);
+ qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
} else {
rc = qemuMonitorTransaction(priv->mon, &snapctxt->actions);
- qemuDomainObjExitMonitor(driver, snapctxt->vm);
+ qemuDomainObjExitMonitor(snapctxt->vm);
for (i = 0; i < snapctxt->ndd; i++) {
qemuSnapshotDiskData *dd = snapctxt->dd + i;
snapshot = qemuSnapshotCreate(vm, domain, def, driver, cfg, flags);
}
- qemuDomainObjEndAsyncJob(driver, vm);
+ qemuDomainObjEndAsyncJob(vm);
return snapshot;
}
}
endjob:
- qemuProcessEndJob(driver, vm);
+ qemuProcessEndJob(vm);
return ret;
}
}
endjob:
- qemuDomainObjEndJob(driver, vm);
+ qemuDomainObjEndJob(vm);
return ret;
}
projects / thirdparty / libvirt.git / commitdiff
